#if 0

#include <boost/variant2/variant.hpp>
#include <variant>
#include <type_traits>

// adapt boost::variant2 visitation for std::variant
namespace boost::variant2 {
    template<class... T>
    struct variant_size<std::variant<T...>>
	     : variant_size<boost::variant2::variant<T...>>
	 {};
}

template<std::size_t I, class... T>
constexpr std::variant_alternative_t<I, std::variant<T...>>& unsafe_get(std::variant<T...>& v) {
	 static_assert( I < sizeof...(T), "Index out of bounds" );
	 return *std::get_if<I>(&v);
}

template<std::size_t I, class... T>
constexpr std::variant_alternative_t<I, std::variant<T...>>&& unsafe_get(std::variant<T...>&& v) {
	 static_assert( I < sizeof...(T), "Index out of bounds" );
	 return std::move( *std::get_if<I>(&v) );
}

template<std::size_t I, class... T>
constexpr std::variant_alternative_t<I, std::variant<T...>> const& unsafe_get(std::variant<T...> const& v) {
	 static_assert( I < sizeof...(T), "Index out of bounds" );
	 return *std::get_if<I>(&v);
}

template<std::size_t I, class... T>
constexpr std::variant_alternative_t<I, std::variant<T...>> const&& unsafe_get(std::variant<T...> const&& v) {
	 static_assert( I < sizeof...(T), "Index out of bounds" );
	 return std::move( *std::get_if<I>(&v) );
}


template<class... Ts> struct overloaded : Ts... { using Ts::operator()...; };
template<class... Ts> overloaded(Ts...) -> overloaded<Ts...>;

struct T0 {};
struct T1 {};
struct T2 {};
struct T3 {};
struct T4 {};
struct T5 {};
struct T6 {};
struct T7 {};
struct T8 {};
struct T9 {};

using example_variant = std::variant<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
int do_visit(example_variant v) {
	  return boost::variant2::visit(overloaded{
	     [](T0) { return 3; },
	     [](T1) { return 5; },
	     [](T2) { return 8; },
	     [](T3) { return 9; },
	     [](T4) { return 10; },
	     [](T5) { return 11; },
	     [](T6) { return 12; },
	     [](T7) { return 13; },
	     [](T8) { return 14; },
	     [](T9) { return 233; }
	 }, v);
}


#endif