diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index dd3b7fe..ec9c62e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -38,18 +38,31 @@ jobs:
       - name: Build and Test
         run: bash tools/earthly.sh +build-gcc-10.3
 
+  # XXX: BROKEN due to compiler bugs. Investigate at a later date.
   build-clang16:
-    name: Build for Clang 16
+    name: Build for Clang 16 [Compiler bugs]
     runs-on: ubuntu-latest
+    if: ${{false}} # Skipped
     steps:
       - name: Checkout
         uses: actions/checkout@v4
       - name: Build and Test
         run: bash tools/earthly.sh +build-clang-16
 
+  build-clang17:
+    name: Build for Clang 17 [Compiler bugs]
+    runs-on: ubuntu-latest
+    if: ${{false}} # Skipped
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+      - name: Build and Test
+        run: bash tools/earthly.sh +build-clang-17
+
   build-vs2019:
-    name: Build for VS 2019
+    name: Build for VS 2019 [Compiler bugs]
     runs-on: windows-2019
+    if: ${{false}} # Skipped
     steps:
       - name: Checkout
         uses: actions/checkout@v4
diff --git a/Earthfile b/Earthfile
index 585204c..4ffaaf7 100644
--- a/Earthfile
+++ b/Earthfile
@@ -89,6 +89,9 @@ build-gcc:
 build-gcc-10.3:
     DO +ALPINE_BUILD --version=3.15 --prep=ALPINE_PREP_GCC --cxx_flags="-fcoroutines" --runtime_debug=false
 
+build-clang-17:
+    DO +ALPINE_BUILD --version=3.19 --prep=ALPINE_PREP_CLANG
+
 build-clang-16:
     DO +ALPINE_BUILD --version=3.18 --prep=ALPINE_PREP_CLANG
 
diff --git a/render.py b/render.py
new file mode 100644
index 0000000..f2a1b71
--- /dev/null
+++ b/render.py
@@ -0,0 +1,47 @@
+# /// script
+# requires-python = ">=3.8"
+# dependencies = []
+#   "jinja2",
+# ]
+# ///
+import sys
+from typing import Any, Sequence
+import jinja2
+import argparse
+
+
+def format_each(iterable: Any, s: str) -> Any:
+    return (s.format(x) for x in iterable)
+
+
+_GENERATED_FILE_WARNING = """// d8888b.  .d88b.       d8b   db  .d88b.  d888888b      d88888b d8888b. d888888b d888888b
+// 88  `8D .8P  Y8.      888o  88 .8P  Y8. `~~88~~'      88'     88  `8D   `88'   `~~88~~'
+// 88   88 88    88      88V8o 88 88    88    88         88ooooo 88   88    88       88
+// 88   88 88    88      88 V8o88 88    88    88         88~~~~~ 88   88    88       88
+// 88  .8D `8b  d8'      88  V888 `8b  d8'    88         88.     88  .8D   .88.      88
+// Y8888D'  `Y88P'       VP   V8P  `Y88P'     YP         Y88888P Y8888D' Y888888P    YP"""
+
+
+def gen_warning(filename: str) -> str:
+    return f"{_GENERATED_FILE_WARNING}\n\n// This file was GENERATED from {filename}"
+
+
+def main(argv: Sequence[str]) -> int:
+    parser = argparse.ArgumentParser(
+        description="Renders a Jinja template from stdin to stdout"
+    )
+    parser.parse_args(argv)  # No arguments, but throws if arguments are provided
+    template_str = sys.stdin.read()
+    env = jinja2.Environment(
+        line_statement_prefix="#%",
+        line_comment_prefix="##",
+    )
+    env.filters["format_each"] = format_each  # type: ignore
+    tmpl = env.from_string(template_str)
+    s = tmpl.render(generated_file_notice=gen_warning)
+    sys.stdout.write(s)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main(sys.argv[1:]))
diff --git a/src/neo/addressof.hpp b/src/neo/addressof.hpp
index 694516e..ea56260 100644
--- a/src/neo/addressof.hpp
+++ b/src/neo/addressof.hpp
@@ -2,13 +2,7 @@
 
 #include "./attrib.hpp"
 
-// clang-format off
-#if (NEO_HAS_BUILTIN(__builtin_addressof) || defined(_MSC_VER))
-#define HAS_ADDROF_INTRIN 1
-#endif
-// clang-format on
-
-#ifndef HAS_ADDROF_INTRIN
+#if !NEO_HAS_BUILTIN(__builtin_addressof)
 #include <memory>
 #endif
 
@@ -20,7 +14,7 @@ namespace neo {
  */
 template <typename T>
 constexpr T* addressof(T& arg) noexcept {
-#if HAS_ADDROF_INTRIN
+#if NEO_HAS_BUILTIN(__builtin_addressof)
     return __builtin_addressof(arg);
 #else
     return std::addressof(arg);
@@ -30,14 +24,10 @@ constexpr T* addressof(T& arg) noexcept {
 template <typename T>
 const T& addressof(const T&&) = delete;
 
-#if HAS_ADDROF_INTRIN
+#if NEO_HAS_BUILTIN(__builtin_addressof)
 #define NEO_ADDRESSOF(X) __builtin_addressof((X))
 #else
 #define NEO_ADDRESSOF(X) std::addressof((X))
 #endif
 
 }  // namespace neo
-
-#ifdef HAS_ADDROF_INTRIN
-#undef HAS_ADDROF_INTRIN
-#endif
diff --git a/src/neo/attrib.hpp b/src/neo/attrib.hpp
index 9be8965..e8966d4 100644
--- a/src/neo/attrib.hpp
+++ b/src/neo/attrib.hpp
@@ -73,6 +73,7 @@
 #define NEO_MSVC_HAS_BUILTIN__is_unbounded_array
 #define NEO_MSVC_HAS_BUILTIN__is_union
 #define NEO_MSVC_HAS_BUILTIN__underlying_type
+#define NEO_MSVC_HAS_BUILTIN__builtin_addressof
 
 #define NEO_MSVC_HAS_BUILTIN__make_integer_seq
 
diff --git a/src/neo/channel.detail.hpp b/src/neo/channel.detail.hpp
new file mode 100644
index 0000000..d5b5628
--- /dev/null
+++ b/src/neo/channel.detail.hpp
@@ -0,0 +1,442 @@
+#pragma once
+
+#include "./channel_fwd.hpp"
+
+#include <neo/addressof.hpp>
+#include <neo/attrib.hpp>
+#include <neo/concepts.hpp>
+#include <neo/optional.hpp>
+#include <neo/unit.hpp>
+
+#include <coroutine>
+#include <exception>
+
+namespace neo::_channel_detail {
+
+// Information used to coordinate between nested channel coroutines
+struct stack_resume_info {
+    std::exception_ptr      thrown;
+    std::coroutine_handle<> co_handle;
+};
+
+// Used to extract the coroutine handle from a `from_channel` wrapper.
+struct from_chan_coro_getter {
+    template <typename C>
+    static auto getit(from_channel<C>& from) noexcept {
+        return from._coro;
+    }
+};
+
+/**
+ * @brief Abstract base class for send/yield handling
+ *
+ * @tparam T
+ */
+template <typename T>
+class io_base {
+public:
+    /**
+     * @brief Push the referred-to value to the handler.
+     */
+    virtual void put(add_lvalue_reference_t<nonvoid_t<T>>) = 0;
+};
+
+/**
+ * @brief Implements the return value aspect of channel
+ *
+ * @tparam Derived The derived promise type (CRTP)
+ */
+template <typename Derived>
+struct return_part;
+
+/**
+ * @brief Implements the yielding aspect channels. `T` must be `void` or an
+ * lvalue-reference type. This type may be empty.
+ *
+ * Derives from io_base<T>. Defines a `get() -> nonvoid_t<T>&` method.
+ */
+template <typename T>
+struct yield_io;
+
+/**
+ * @brief Implements the sending+resuming aspect for channels. `T` must be `void`
+ * or an lvalue-reference type. This type must be constructed with a coroutine
+ * handle.
+ *
+ * Derives from io_base<T>. Defines a `get() -> nonvoid_t<T>&` method.
+ */
+template <typename T>
+struct send_io;
+
+template <typename OuterSend, typename InnerSend, typename OuterYield, typename InnerYield>
+concept nested_channel_yield_compatible = requires {
+    // The type being send to the outer channel should be convertible to the type that the inner
+    // channel expects to be sent
+    requires convertible_to<OuterSend, InnerSend>;
+    // The type yielded by the sub-channel must be convertible to the parent channel's yield type
+    requires convertible_to<InnerYield, OuterYield>;
+    // Passing the yield/send values through should not construct any references to temporary
+    // objects:
+    requires not reference_constructible_from_temporary<InnerSend, OuterSend>;
+    requires not reference_constructible_from_temporary<OuterYield, InnerYield>;
+};
+
+/**
+ * @brief Promise type for channels
+ */
+template <typename Yield, typename Send, typename Return>
+class promise : public return_part<promise<Yield, Send, Return>> {
+    // The coroutine handle type for this promise
+    using handle_type = std::coroutine_handle<promise>;
+
+    // Grant other promises access to our components, to allow updating the yield/send IO
+    template <typename, typename, typename>
+    friend class _channel_detail::promise;
+
+    // The yield handler for this promise.
+    NEO_NO_UNIQUE_ADDRESS yield_io<add_lvalue_reference_t<Yield>> _self_yielder;
+    // The send handler for this promise. We pass the handle to this coroutine so that
+    // the send_io can resume this coroutine when the caller sends on the channel.
+    send_io<add_lvalue_reference_t<Send>> _self_sender{handle_type::from_promise(*this)};
+
+    /**
+     * @brief Pointer to the active send-handler for the channel.
+     *
+     * In the non-recursive case, this pointer always points to our own send-handler.
+     * If the coroutine yields-from another channel<>, this pointer will be temporarily
+     * updated to point to the send-handler for that sub-channel.
+     *
+     * See `nested_awaiter` for where this pointer is manipulated.
+     */
+    io_base<add_lvalue_reference_t<Send>>* _sender = &_self_sender;
+    /**
+     * @brief Pointer to the yield-handler for the channel.
+     *
+     * Like the send-handler, this usually points to our own yield handler, but it
+     * may be updated by a parent coroutine in `nested_awaiter`.
+     */
+    io_base<add_lvalue_reference_t<Yield>>* _yielder = &_self_yielder;
+
+    /**
+     * @brief Pointer-to-pointer-to the root sender for the current channel
+     * stack. This pointer will be updated by calls to the nested_yielded, and
+     * is used to update the `_sender` pointer on the root channel when a sub-channel
+     * begins execution.
+     */
+    io_base<add_lvalue_reference_t<Send>>** _root_sender_ptr = &_sender;
+
+    /**
+     * @brief Information about the parent channel coroutine, if applicable.
+     *
+     * This pointer is only assigned by a parent coroutine in `nested_awaitable`.
+     */
+    stack_resume_info* _parent = nullptr;
+
+public:
+    // Conversion helper for the channel
+    struct init {
+        // Coroutine handle for the channel
+        handle_type co;
+    };
+
+    constexpr init get_return_object() noexcept { return {handle_type::from_promise(*this)}; }
+
+    // Always start the channel coroutine as suspended
+    std::suspend_always initial_suspend() const noexcept { return {}; }
+
+    // Push a value into the channel, also resuming it
+    void send_value(nonvoid_t<Send>& arg) { this->_sender->put(arg); }
+
+    /**
+     * @brief Obtain a reference to the yielded value. If `void`, then returns
+     * a `unit&`
+     */
+    nonvoid_t<Yield>& get_yielded() noexcept {
+        return static_cast<nonvoid_t<Yield>&>(_self_yielder.get());
+    }
+
+    void unhandled_exception() {
+        if (this->_parent) {
+            // We are a sub-channel, and we want the parent coroutine to resume
+            // with the exception that we just caught.
+            this->_parent->thrown = std::current_exception();
+            // Don't rethrow, just stop:
+            return;
+        }
+        // No parent coroutine is running, so re-throw into the resumer
+        throw;
+    }
+
+    // An awaitable used at the end of a channel to optionally resume a parent
+    // channel, if present
+    struct parent_resumer {
+        promise& self;
+
+        // We always suspend ourself
+        constexpr bool await_ready() const noexcept { return false; }
+        // Symmetric transfer to another coroutine:
+        constexpr std::coroutine_handle<> await_suspend(auto) const noexcept {
+            if (self._parent) {
+                // We are executing as part of a sub-channel. We want to resume
+                // the coroutine that started us
+                return self._parent->co_handle;
+            }
+            // We are not executing as a child, so run the noop coroutine, which
+            // will just immediately return to the resumer
+            return std::noop_coroutine();
+        }
+        // This is never called, as we are done executing
+        void await_resume() const noexcept { std::terminate(); }
+    };
+
+    parent_resumer final_suspend() noexcept { return {*this}; }
+
+    /**
+     * @brief Awaiter type generated by `co_yield` expressions. Unconditionally
+     * suspends the coroutine and stores a pointer to the yielded value in a place
+     * that is accessible to the caller
+     *
+     * @tparam YieldTmp The temporary object type used to store the yielded value.
+     * May be a reference.
+     */
+    template <typename YieldTmp>
+    struct yield_awaiter {
+        promise& self;
+        YieldTmp yielded_value;
+
+        constexpr bool await_ready() const noexcept { return false; }
+
+        /// Upon resumption, return the sent value that caused the resume:
+        Send await_resume() const noexcept {
+            return static_cast<add_rvalue_reference_t<Send>>(self._self_sender.get());
+        }
+
+        // Upon suspend, store a pointer to the yielded value:
+        constexpr void await_suspend(auto) noexcept { self._yielder->put(yielded_value); }
+    };
+
+    /**
+     * @brief Yield a value. Primary overload.
+     *
+     * @param y A reference to the value being yielded.
+     *
+     * This function only records a reference to the yielded value, and does not
+     * copy/move the value. This relies on the compiler extending the lifetime of
+     * the yield operand to the full yield expression, allowing the reference to
+     * outlive the entire coroutine suspension that is caused by that `co_yield`.
+     *
+     * If the Yield type is a non-reference type, then this function
+     * accepts an rvalue-reference to the yield type, which may incur an automatic
+     * conversion at the yield site. If the Yield type is a reference type, then
+     * this function will accept exactly that reference type as an operand.
+     */
+    yield_awaiter<nonvoid_t<Yield>&> yield_value(nonvoid_t<Yield>&& y) noexcept {
+        return {*this, y};
+    }
+
+    template <typename Arg>
+        requires reference_constructible_from_temporary<Yield, Arg>
+    [[deprecated(
+        "Your channel's yield-type is a reference type, but the operand of your `co_yield` "
+        "expression would bind a the yielded reference to a temporary. This is safe, but probably"
+        "a mistake.")]] void
+    yield_value(Arg&& arg)
+        = delete;
+
+    /**
+     * @brief Yield with a possible conversion.
+     *
+     * @note This overload is only visible if Yield IS NOT a reference type. This
+     * makes two overloads of `yield_value` available: `yield_value(T&&)` and `yield_value(const
+     * T&)`, which allows the yielding of `T` values that will either move or copy as-needed.
+     *
+     * If Yield is an lvalue reference, then Yield&& will be an lvalue reference, and the requires
+     * constraint on this function will fail.
+     *
+     * This will always accept a reference-to-const of the underlying type, which
+     * results in allowing conversions to the yielded type
+     */
+    constexpr yield_awaiter<nonvoid_t<Yield>> yield_value(nonvoid_t<Yield> const& y) noexcept
+        // This overload is only visible for non-lref types:
+        requires(not reference_type<Yield>)
+        // We must be able to copy to the underlying type
+        and convertible_to<nonvoid_t<Yield> const&, Yield>
+    {
+        // In this case, the yield_awaiter takes the yielded object by-value (using a copy), because
+        // we cannot reference-extend the object.
+        return {*this, y};
+    }
+
+    /**
+     * @brief Awaiter generated by `co_yield from_channel(...)`.
+     *
+     * This connects sub-channels to this channel and resumes them immediately.
+     *
+     * @tparam OtherCo The coroutine handle type used by the other channel. Note
+     * that the channel might not be equivalent to our own!
+     */
+    template <typename OtherCo>
+    struct nested_awaiter;
+
+    template <typename OtherYield, typename OtherSend, typename OtherReturn>
+    struct nested_awaiter<std::coroutine_handle<promise<OtherYield, OtherSend, OtherReturn>>> {
+        using OtherHandle = std::coroutine_handle<promise<OtherYield, OtherSend, OtherReturn>>;
+        promise& self;
+        // coroutine handle for the sub-channel
+        OtherHandle child_co_handle;
+        // Resumption info that is used to coordinate with the sub-channel
+        stack_resume_info resume_info{};
+
+        // We are only done if the sub-channel is already done
+        constexpr bool await_ready() const noexcept { return child_co_handle.done(); }
+
+        struct sender_link : io_base<add_lvalue_reference_t<Send>> {
+            io_base<add_lvalue_reference_t<OtherSend>>* _send_child;
+
+            void put(add_lvalue_reference_t<nonvoid_t<Send>> s) { _send_child->put(s); }
+        };
+
+        struct yielder_link : io_base<add_lvalue_reference_t<OtherYield>> {
+            io_base<add_lvalue_reference_t<Yield>>* _parent_yield;
+
+            void put(nonvoid_t<OtherYield>& s) { _parent_yield->put(s); }
+        };
+
+        sender_link  _sender2{};
+        yielder_link _yielder2{};
+
+        io_base<add_lvalue_reference_t<OtherSend>>*
+        get_sender_link(io_base<add_lvalue_reference_t<OtherSend>>* child_sender) {
+            if constexpr (weak_same_as<OtherSend, Send>) {
+                return child_sender;
+            } else {
+                _sender2._send_child = child_sender;
+                return &_sender2;
+            }
+        }
+
+        io_base<add_lvalue_reference_t<OtherYield>>*
+        get_yielder_link(io_base<add_lvalue_reference_t<Yield>>* parent_yielder) {
+            if constexpr (weak_same_as<OtherYield, Yield>) {
+                return parent_yielder;
+            } else {
+                _yielder2._parent_yield = parent_yielder;
+                return &_yielder2;
+            }
+        }
+
+        // Suspension semantics for yielding-from sub-channels:
+        constexpr auto await_suspend(handle_type this_co) noexcept {
+            // The promise of the sub-channel:
+            auto& child_pr = child_co_handle.promise();
+            // Connect the root send-handler for our own channel stack to the send-handler
+            // for the sub-channel. This ensures that when the resumer calls `send()` on this
+            // channel (or a parent thereof), the sent value will be immediately directed to the new
+            // leaf channel, and that leaf channel will be resumed instead of the suspended parent
+            // channels.
+            *self._root_sender_ptr = this->get_sender_link(child_pr._sender);
+            // Tell the sub-channel where the root sender-handler-pointer lives, in case it needs to
+            // spawn any sub-channels of its own:
+            child_pr._root_sender_ptr = self._root_sender_ptr;
+            // Tell the sub-channel ot use our the current yielder as its yielder. This may point to
+            // a yielder of a parent channel as well.
+            child_pr._yielder = this->get_yielder_link(self._yielder);
+            // Give the sub-channel a way to coordinate with this channel.
+            child_pr._parent = &resume_info;
+            // Tell the sub-channel our own coroutine handle so that it can resume us when it
+            // returns.
+            resume_info.co_handle = this_co;
+            // Symmetric transfer: Begin executing the subchannel
+            return child_co_handle;
+        }
+
+        // Sub-channel returns: Now we return the return value from that channel from
+        // the `co_yield` expression itself.
+        constexpr OtherReturn await_resume() const {
+            // Re-connect the root sender to this channel now that it has become the leaf channel
+            // again.
+            *self._root_sender_ptr = &self._self_sender;
+            if (resume_info.thrown) {
+                // The subchannel threw an exception during execution, so we should rethrow it too
+                std::rethrow_exception(resume_info.thrown);
+            }
+            // Get the return value
+            return static_cast<add_rvalue_reference_t<OtherReturn>>(
+                child_co_handle.promise().get_returned());
+        }
+    };
+
+    template <typename OtherYield, typename OtherSend, typename OtherReturn>
+        requires nested_channel_yield_compatible<Send, OtherSend, Yield, OtherYield>
+    auto yield_value(from_channel<channel<OtherYield, OtherSend, OtherReturn>> from) {
+        auto other_co = from_chan_coro_getter::getit(from);
+        return nested_awaiter<decltype(other_co)>{*this, other_co};
+    }
+};
+
+template <typename Yield, typename Send>
+struct promise_base;
+
+template <typename Yield, typename Send, typename Return>
+struct return_part<promise<Yield, Send, Return>> {
+    using Derived = promise<Yield, Send, Return>;
+
+    optional<Return> _retval;
+
+    constexpr Return& get_returned() noexcept { return *_retval; }
+
+    template <implicit_convertible_to<Return> Arg>
+    constexpr void return_value(Arg&& arg) {
+        _retval.emplace(NEO_FWD(arg));
+    }
+};
+
+template <typename Yield, typename Send, void_type Return>
+struct return_part<promise<Yield, Send, Return>> {
+    constexpr void return_void() noexcept {}
+    constexpr unit get_returned() noexcept { return {}; }
+};
+
+template <lvalue_reference_type Ref>
+struct send_io<Ref> : io_base<Ref> {
+    explicit send_io(std::coroutine_handle<> co) noexcept
+        : resumer(co) {}
+    add_pointer_t<Ref>      ptr;
+    std::coroutine_handle<> resumer;
+
+    void put(Ref ref) {
+        ptr = NEO_ADDRESSOF(ref);
+        resumer.resume();
+    }
+    Ref get() const noexcept { return *ptr; }
+};
+
+template <void_type Void>
+struct send_io<Void> : io_base<void> {
+    explicit send_io(std::coroutine_handle<> co) noexcept
+        : resumer(co) {}
+
+    std::coroutine_handle<> resumer;
+    static inline unit      nil;
+
+    void  put(unit&) override { resumer.resume(); }
+    unit& get() const noexcept { return nil; }
+};
+
+template <lvalue_reference_type T>
+struct yield_io<T> : io_base<T> {
+    add_pointer_t<T> ptr;
+    void             put(T ref) override { ptr = NEO_ADDRESSOF(ref); }
+
+    T get() const noexcept { return *ptr; }
+};
+
+template <void_type T>
+struct yield_io<T> : io_base<void> {
+    void put(unit&) override {}
+
+    static inline unit nil;
+    unit&              get() const noexcept { return nil; }
+};
+
+}  // namespace neo::_channel_detail
diff --git a/src/neo/channel.hpp b/src/neo/channel.hpp
index 48228d7..4af3919 100644
--- a/src/neo/channel.hpp
+++ b/src/neo/channel.hpp
@@ -1,40 +1,73 @@
 #pragma once
 
-#include <neo/channel_fwd.hpp>
+#include "./channel.detail.hpp"
 
 #include <neo/attrib.hpp>
-#include <neo/opt_ref.hpp>
-#include <neo/optional.hpp>
+#include <neo/channel_fwd.hpp>
 #include <neo/type_traits.hpp>
+#include <neo/unit.hpp>
 
 #include <coroutine>
-#include <exception>
+#include <type_traits>
 
 namespace neo {
 
+/**
+ * @brief A bidirectional communication channel coroutine type.
+ *
+ * The channel starts in a suspended state, and may be launched by calling `open()` to
+ * get a `channel_pipe`, or `begin()` to return an iterator (only available for some
+ * configurations of the channel).
+ *
+ * @tparam Yield The type that will be produced by the coroutine, accessed using the pipe's
+ *      `current()`/`take_current()` method.
+ * @tparam Send The type that will be sent to the coroutine, delivered by the pipe `send` method,
+ *      and the return value of plain `co_yield` expressions within the coroutine.
+ * @tparam Return The type that should be `co_returned` from the coroutine. Accessible
+ *      from the invoker as the `return_value()` method on the channel pipe.
+ *
+ * Any of the above template parameters may be `void`, with the following notes:
+ *
+ * • If the `Yield` parameter is void, then the `co_yield` expressions must yield
+ *   a literal zero "0", and the `current()` method will return void.
+ * • If the `Send` parameter is void, then the `co_yield` expression will have
+ *   type `void`, and `send()` must be called with no arguments.
+ * • If the `Return` parameter is void, then the `return_value()` function will
+ *   also have a return type of `void`.
+ *
+ * Channel coroutines may also co_yield other channels, using the `from_channel`
+ * wrapper.
+ */
 template <typename Yield, typename Send, typename Return>
 class channel {
 public:
-    using promise_type = _channel_detail::promise<Yield, Send, Return>;
-    using send_type    = Send;
-    using yield_type   = Yield;
-    using return_type  = Return;
-
-    using pipe_type = channel_pipe<Yield, Send, Return>;
-
-private:
-    template <typename, typename, typename>
-    friend class _channel_detail::promise;
-
-    template <typename>
-    friend class from_channel;
+    /// The type given for the Yield template parameter
+    using yield_type = Yield;
+    /// The type given for the Send template parameter
+    using send_type = Send;
+    /// The type given for the Return template parameter
+    using return_type = Return;
+    // The promise type of the channel
+    using promise_type = _channel_detail::promise<yield_type, send_type, return_type>;
 
-    using handle_type = std::coroutine_handle<promise_type>;
+    /**
+     * @brief The type returned by `channel::open()`, used for communicating with
+     * the channel.
+     */
+    using pipe_type = channel_pipe<yield_type, send_type, return_type>;
 
 public:
+    /**
+     * @brief Launch the channel and begin execution.
+     *
+     * The behavior of calling this function more than once is undefined
+     *
+     * @return pipe_type A new active channel pipe
+     */
     pipe_type open() {
         // Initiate the channel:
         _coro.resume();
+        // The channel is now paused and ready with its first value (or immediately done)
         return pipe_type(_coro);
     }
 
@@ -61,8 +94,20 @@ class channel {
         return *this;
     }
 
-    constexpr from_channel<channel> operator~() noexcept;
+    /**
+     * @brief Return a from_channel that can be co_yielded to start a nested channel.
+     *
+     * See `from_channel` for more information.
+     */
+    constexpr from_channel<channel> operator*() noexcept;
+
+private:
+    template <typename>
+    friend class from_channel;
 
+    using handle_type = std::coroutine_handle<promise_type>;
+
+public:
     class iterator {
         handle_type _coro;
 
@@ -74,9 +119,7 @@ class channel {
         struct sender {
             handle_type co;
 
-            void operator=(typename promise_type::send_put send) const&& {
-                co.promise().send_value(NEO_FWD(send));
-            }
+            void operator=(nonvoid_t<send_type>&& send) const&& { co.promise().send_value(send); }
         };
 
     public:
@@ -118,102 +161,106 @@ class channel {
 
     constexpr std::default_sentinel_t end() const noexcept { return {}; }
 
+    constexpr channel(typename promise_type::init init) noexcept
+        : _coro(init.co) {}
+
 private:
     handle_type _coro;
-
-    constexpr explicit channel(handle_type h) noexcept
-        : _coro(h) {}
 };
 
+/**
+ * @brief Communication handle for a neo::channel
+ *
+ * Do not construct this directly. Use neo::channel::open to obtain an instance
+ * of this type.
+ */
 template <typename Yield, typename Send, typename Return>
 class channel_pipe {
-    using promise     = _channel_detail::promise<Yield, Send, Return>;
-    using handle_type = std::coroutine_handle<promise>;
-    handle_type _coro;
-
-    friend class channel<Yield, Send, Return>;
-
-    explicit channel_pipe(handle_type co)
-        : _coro(co) {}
 
 public:
-    using send_type   = Send;
-    using yield_type  = Yield;
+    /// The type to send to the channel
+    using send_type = Send;
+    /// The type yielded by the channel
+    using yield_type = Yield;
+    /// The final result type of the channel
     using return_type = Return;
-    using send_put    = promise::send_put;
 
     /**
-     * @brief Returns `true` if the channel has co_returned
+     * @brief Returns `true` if the channel has co_returned normally
      */
-    constexpr bool done() const noexcept { return _coro.promise().has_returned(); }
+    constexpr bool done() const noexcept { return _coro.done(); }
 
     /**
      * @brief Obtain the most-recently yielded value from the channel.
      *
-     * This function will always return an lvalue-reference. Use take_current()
-     * to obtain the value from the coroutine casted to the true yield type.
+     * If `yield_type` is `void`, returns `void`. Otherwise, returns an lvalue-reference
+     * to the yielded value.
+     *
+     * @pre `not done()`
      */
     constexpr add_lvalue_reference_t<yield_type> current() const noexcept {
-        return _coro.promise().get_yielded();
+        return static_cast<add_lvalue_reference_t<yield_type>>(_coro.promise().get_yielded());
     }
 
     /**
-     * @brief Take the current object yielded by the channel.
+     * @brief Take the current object yielded by the channel. May move-construct
+     * from the underlying object if the yield type is an object type
      *
-     * @return _types::yield_backward
+     * @pre `not done()`
      */
-    constexpr add_rvalue_reference_t<yield_type> take_current() noexcept {
+    constexpr yield_type take_current() noexcept {
         return static_cast<add_rvalue_reference_t<yield_type>>(_coro.promise().get_yielded());
     }
 
     /**
-     * @brief Send a value. This is the main overload
+     * @brief Send a value and resume the channel.
      *
-     * The type of the parameter depends on the template parameter for sending.
-     * If Send is void, this function is not available.
+     * Accepts an rvalue-reference to the send type. This overload is only
+     * available if the send type is not `void`.
      *
-     * @param arg The value to send
+     * @pre `not done()`
      */
-    constexpr void send(send_put arg)
-        requires(not neo_is_void(send_type))
+    constexpr void send(nonvoid_t<send_type>&& arg)
+        requires(not void_type<send_type>)
     {
-        _coro.promise().send_value(NEO_FWD(arg));
+        _coro.promise().send_value(arg);
     }
 
     /**
-     * @brief Send a value with a possible conversion.
-     *
-     * @note This overload is only visible if Send IS NOT an lvalue-reference type.
+     * @brief Send a value with a possible conversion, and resume the channel
      *
-     * If Send is an lvalue reference, then Send&& will be an lvalue reference, and the requires
-     * constraint on this function will fail.
+     * @note This overload is only visible if Send IS NOT a reference type.
      *
      * This will always accept a reference-to-const of the underlying type, which
      * results in allowing conversions to the yielded type
      *
      * @param y
      * @return yield_awaiter<remove_cvref_t<yield_forward>>
+     *
+     * @pre `not done()`
      */
-    constexpr void send(const_reference_t<send_put> arg)
-        requires(not void_type<send_type>)
+    constexpr void send(nonvoid_t<send_type> const& arg)
         // Require that we are not sending lvalue-references:
-        and rvalue_reference_type<add_rvalue_reference_t<send_type>>
+        requires(not reference_type<send_type>)
         // Require that we can construct a send value from the const-reference:
-        and convertible_to<const_reference_t<send_type>, remove_cvref_t<send_type>>
+        and convertible_to<nonvoid_t<send_type> const&, send_type>
     {
-        remove_cvref_t<send_put> x = NEO_FWD(arg);
-        _coro.promise().send_value(NEO_FWD(x));
+        nonvoid_t<send_type> tmp(arg);
+        _coro.promise().send_value(tmp);
     }
 
     /**
-     * @brief Send a void value (resumes the coroutine channel)
+     * @brief Send a void value and resume the channel
      *
      * This overload is only visible if Send is `void`
+     *
+     * @pre `not done()`
      */
     constexpr void send()
         requires void_type<send_type>
     {
-        _coro.promise().send_value(nullptr);
+        unit nil;
+        _coro.promise().send_value(nil);
     }
 
     /**
@@ -221,293 +268,73 @@ class channel_pipe {
      *
      * If the Return type is void, this function returns void. Otherwise,
      * this function will always return an lvalue-reference.
+     *
+     * @pre `done()`
      */
     constexpr add_lvalue_reference_t<return_type> return_value() const noexcept {
-        return _coro.promise().get_returned();
+        return static_cast<add_lvalue_reference_t<return_type>>(_coro.promise().get_returned());
     }
 
     /**
      * @brief Take the final return value from the coroutine.
      *
-     * This returns exactly yield_type, which may be an rvalue
+     * This returns exactly yield_type, which may be an rvalue.
+     *
+     * @pre `done()`
      */
     constexpr return_type take_return_value() noexcept {
-        return _coro.promise().take_return_value();
+        return static_cast<add_rvalue_reference_t<return_type>>(_coro.promise().get_returned());
     }
+
+private:
+    // Promise type for the coroutine
+    using promise = _channel_detail::promise<Yield, Send, Return>;
+    // Coroutine handle type for the channel
+    using handle_type = std::coroutine_handle<promise>;
+
+    // Allow our channel to call our constructor
+    friend channel<yield_type, send_type, return_type>;
+
+    /**
+     * @brief Construct a new channel pipe object from a channel's coroutine handle
+     */
+    constexpr explicit channel_pipe(handle_type co) noexcept
+        : _coro(co) {}
+
+private:
+    // The coroutine handle for the channel
+    handle_type _coro;
 };
 
+/**
+ * @brief Within a channel coroutine, allows yielding control to a sub-channel.
+ *
+ * Within a channel coroutine, a `co_yield` expression may accept a `from_channel`
+ * as an operand, which tells the coroutine to suspend and delegate further
+ * execution to the new channel. Values sent/yielded into the channel will be
+ * piped into the child coroutine until it returns. The return value from the
+ * child coroutine is the result value of the `co_yield` expression in the
+ * parent.
+ */
 template <typename C>
 class from_channel {
     // The wrapped channel coroutine
     typename remove_cvref_t<C>::handle_type _coro;
 
-    template <typename, typename>
-    friend struct _channel_detail::promise_base;
+    friend _channel_detail::from_chan_coro_getter;
 
 public:
     explicit from_channel(const C& c) noexcept
         : _coro(c._coro) {}
 };
 
+// CTAD for from_channnel
 template <typename C>
 explicit from_channel(C const&) -> from_channel<C>;
 
 template <typename Y, typename S, typename R>
-constexpr from_channel<channel<Y, S, R>> channel<Y, S, R>::operator~() noexcept {
+constexpr from_channel<channel<Y, S, R>> channel<Y, S, R>::operator*() noexcept {
     return from_channel(*this);
 }
 
-namespace _channel_detail {
-
-template <typename ReturnVal>
-struct promise_return {
-    using return_get  = ReturnVal&;
-    using return_take = ReturnVal;
-    neo::nano_opt<ReturnVal> _return_value;
-    bool                     _did_throw = false;
-    template <neo::convertible_to<ReturnVal> U>
-    constexpr void return_value(U&& arg) noexcept(nothrow_constructible_from<ReturnVal, U>) {
-        _return_value.emplace(NEO_MOVE(arg));
-    }
-    constexpr bool has_returned() const noexcept { return _return_value.has_value() or _did_throw; }
-    constexpr ReturnVal& get_returned() noexcept { return _return_value.get(); }
-    constexpr ReturnVal  take_return_value() noexcept { return NEO_MOVE(_return_value.get()); }
-};
-
-template <reference_type ReturnRef>
-struct promise_return<ReturnRef> {
-    using return_get  = ReturnRef&;
-    using return_take = ReturnRef&&;
-    neo::optional<ReturnRef> _return_value;
-    bool                     _did_throw = false;
-    template <neo::convertible_to<ReturnRef> U>
-    constexpr void return_value(U&& arg) noexcept(nothrow_constructible_from<ReturnRef, U>) {
-        _return_value = arg;
-    }
-    constexpr bool       has_returned() const noexcept { return !!_return_value or _did_throw; }
-    constexpr return_get get_returned() const noexcept {
-        return static_cast<return_get>(*_return_value);
-    }
-    constexpr return_take take_return_value() const noexcept {
-        return static_cast<return_take>(*_return_value);
-    }
-};
-
-template <>
-struct promise_return<void> {
-    bool           _did_return = false;
-    bool           _did_throw  = false;
-    constexpr void return_void() noexcept { _did_return = true; }
-    constexpr bool has_returned() const noexcept { return _did_return or _did_throw; }
-    constexpr void get_returned() noexcept {}
-    constexpr void take_return_value() noexcept {}
-    using return_get  = void;
-    using return_take = void;
-};
-
-template <typename T>
-struct channel_box {
-    using put_type  = T&&;
-    using get_type  = T&;
-    using take_type = T;
-
-    remove_reference_t<T>* _ptr = nullptr;
-
-    constexpr void      put(put_type p) { _ptr = NEO_ADDRESSOF(p); }
-    constexpr get_type  get() const noexcept { return static_cast<get_type>(*_ptr); }
-    constexpr take_type take() const noexcept { return static_cast<take_type>(*_ptr); }
-};
-
-template <>
-struct channel_box<void> {
-    using put_type  = decltype(nullptr);
-    using get_type  = void;
-    using take_type = void;
-
-    constexpr void put(put_type) {}
-    constexpr void get() const noexcept {}
-    constexpr void take() const noexcept {}
-};
-
-template <>
-struct channel_box<const void> : channel_box<void> {};
-
-template <typename Yield, typename Send>
-struct promise_base {
-    using yield_box = channel_box<Yield>;
-    using send_box  = channel_box<Send>;
-    using yield_put = yield_box::put_type;
-    using yield_get = yield_box::get_type;
-    using send_put  = send_box::put_type;
-
-    virtual std::coroutine_handle<> do_get_handle() noexcept = 0;
-
-    NEO_NO_UNIQUE_ADDRESS yield_box _yield_box;
-    NEO_NO_UNIQUE_ADDRESS send_box  _send_box;
-
-    // In the beginning, we believe that we are the leaf and the root channel in the chain:
-    promise_base* _leaf = this;
-    promise_base* _root = this;
-
-    void connect_leaf(promise_base* leaf) {
-        _leaf        = leaf;
-        _leaf->_root = this;
-    }
-
-    // Keep track of what we are doing here
-    struct parent_resume_info {
-        std::exception_ptr      thrown;
-        std::coroutine_handle<> resume;
-    };
-
-    parent_resume_info* _parent = nullptr;
-
-    // Awaiter for inner channels:
-    template <typename Promise, typename Ret>
-    struct nested_awaiter {
-        promise_base& self;
-        // The inner channel that we are waiting for
-        Promise&           child;
-        parent_resume_info info{};
-
-        constexpr bool await_ready() const noexcept { return child.has_returned(); }
-        constexpr auto await_suspend(std::coroutine_handle<> this_co) noexcept {
-            self._root->connect_leaf(&child);
-            child._parent = &info;
-            info.resume   = this_co;
-            return std::coroutine_handle<Promise>::from_promise(child);
-        }
-
-        constexpr Ret await_resume() const {
-            self._root->connect_leaf(&self);
-            if (info.thrown) {
-                std::rethrow_exception(info.thrown);
-            }
-            return child.take_return_value();
-        }
-    };
-
-    template <typename Ch, typename Promise = remove_reference_t<Ch>::promise_type>
-        requires derived_from<Promise, promise_base>
-    constexpr auto yield_value(from_channel<Ch> ch) {
-        Promise& pr = ch._coro.promise();
-        return nested_awaiter<Promise, typename remove_reference_t<Ch>::return_type>{*this, pr};
-    }
-
-    struct parent_resumer {
-        promise_base& self;
-
-        constexpr bool                    await_ready() const noexcept { return false; }
-        constexpr std::coroutine_handle<> await_suspend(auto) const noexcept {
-            if (self._parent) {
-                return self._parent->resume;
-            }
-            return std::noop_coroutine();
-        }
-        void await_resume() const noexcept { std::terminate(); }
-    };
-
-    constexpr parent_resumer final_suspend() noexcept { return {*this}; }
-
-    std::suspend_always initial_suspend() const noexcept { return {}; }
-
-    /**
-     * @brief Sends a value and resumes the innermost channel
-     *
-     * @return true If the channel returned
-     * @return false Otherwise
-     */
-    constexpr void send_value(send_put arg) {
-        // We're the leaf channel
-        _leaf->_send_box.put(NEO_FWD(arg));
-        _leaf->do_get_handle().resume();
-    }
-
-    /**
-     * @brief Obtain the yielded value
-     */
-    constexpr yield_get get_yielded() const noexcept { return _leaf->_yield_box.get(); }
-
-    // Awaiter for regular yield expressions
-    template <typename Store>
-    struct yield_awaiter {
-        promise_base& self;
-        Store         _store;
-
-        constexpr bool                         await_ready() const noexcept { return false; }
-        constexpr typename send_box::take_type await_resume() const noexcept {
-            // Return the value that was sent to the coroutine upon resume:
-            return self._send_box.take();
-        }
-
-        constexpr void await_suspend(auto) noexcept { self._yield_box.put(NEO_FWD(_store)); }
-    };
-
-    /**
-     * @brief Yield a value. This is the main overload
-     *
-     * The type of the parameter depends on the template parameter for yielding.
-     * If Yield is void, yield_forward is nullptr_t, otherwise it is Yield&&
-     *
-     * @param y The value to yield
-     * @return yield_awaiter<yield_lref>
-     */
-    constexpr yield_awaiter<yield_put> yield_value(yield_put y) noexcept {
-        return {*this, NEO_FWD(y)};
-    }
-
-    /**
-     * @brief Yield with a possible conversion.
-     *
-     * @note This overload is only visible if Yield IS NOT an lvalue-reference type.
-     *
-     * If Yield is an lvalue reference, then Yield&& will be an lvalue reference, and the requires
-     * constraint on this function will fail.
-     *
-     * This will always accept a reference-to-const of the underlying type, which
-     * results in allowing conversions to the yielded type
-     *
-     * @param y
-     * @return yield_awaiter<remove_cvref_t<yield_forward>>
-     */
-    constexpr yield_awaiter<remove_cvref_t<yield_put>>
-    yield_value(const_reference_t<yield_put> y) noexcept
-        // This overload is only visible for non-lref types:
-        requires rvalue_reference_type<yield_put>
-        // We must be able to convert the forwarding reference to the underlying type:
-        and convertible_to<const_reference_t<yield_put>, remove_cvref_t<yield_put>>
-    {
-        return {*this, NEO_FWD(y)};
-    }
-};
-
-template <typename Yield, typename Send, typename Return>
-class promise : public promise_base<Yield, Send>,  //
-                public promise_return<Return> {
-    /// The channel associated with this promise
-    using channel_type = channel<Yield, Send, Return>;
-
-    std::coroutine_handle<> do_get_handle() noexcept override {
-        return std::coroutine_handle<promise>::from_promise(*this);
-    }
-
-public:
-    void unhandled_exception() {
-        if (this->_parent) {
-            this->_parent->thrown = std::current_exception();
-            return;
-        }
-        this->_did_throw = true;
-        throw;
-    }
-
-    constexpr channel_type get_return_object() noexcept {
-        return channel_type{std::coroutine_handle<promise>::from_promise(*this)};
-    }
-
-    constexpr bool did_throw() const noexcept { return this->_did_throw; }
-};
-
-}  // namespace _channel_detail
-
 }  // namespace neo
diff --git a/src/neo/channel.test.cpp b/src/neo/channel.test.cpp
index 8445350..d15f25d 100644
--- a/src/neo/channel.test.cpp
+++ b/src/neo/channel.test.cpp
@@ -18,15 +18,50 @@ channel<int, int> int_chan() {
 }
 
 TEST_CASE("Simple channel") {
-    auto ch = int_chan();
-    auto io = ch.open();
-    CHECK(io.current() == 21);
+    auto ch  = int_chan();
+    auto ch1 = NEO_MOVE(ch);
+    auto io  = ch1.open();
+    auto cur = io.current();
+    CHECK(cur == 21);
     int i = 42;
     io.send(i);
     CHECK(io.done());
     io.return_value();
 }
 
+channel<int> only_yields_chan() {
+    co_yield 42;
+    co_yield 1729;
+}
+
+TEST_CASE("Channel that only yields") {
+    auto ch = only_yields_chan();
+    auto io = ch.open();
+    CHECK(io.current() == 42);
+    io.send();
+    CHECK(io.current() == 1729);
+    io.send();
+    CHECK(io.done());
+    io.return_value();
+}
+
+channel<void, int> only_sends_chan(bool& flag) {
+    auto n = co_yield 0;
+    CHECK(n == 42);
+    flag = true;
+}
+
+TEST_CASE("Channel that only receives values") {
+    bool did_run = false;
+    auto ch      = only_sends_chan(did_run);
+    CHECK_FALSE(did_run);
+    auto io = ch.open();
+    CHECK_FALSE(did_run);
+    io.send(42);
+    CHECK(io.done());
+    CHECK(did_run);
+}
+
 channel<void, void, int> ret_int_chan() {
     co_yield 0;
     // Should not compile:
@@ -43,9 +78,26 @@ TEST_CASE("Non-void return") {
     CHECK(io.return_value() == 42);
 }
 
+channel<int> yields_lvalue_expr() {
+    int foo = 1729;
+    // Yield an lvalue-reference. This will copy the lvalue
+    co_yield foo;
+    const int bar = 42;
+    // Yielding a const& is also good.
+    co_yield bar;
+}
+
+TEST_CASE("Yielding lvalue copies lvalues") {
+    auto ch = yields_lvalue_expr();
+    auto io = ch.open();
+    CHECK(io.current() == 1729);
+    io.send();
+    CHECK(io.current() == 42);
+}
+
 static int                global_int = 0;
 channel<void, void, int&> ret_int2_chan() {
-    co_yield 0;
+    co_yield {};
     // Should not compile:
     // co_return 51;
     global_int = 42;
@@ -65,7 +117,7 @@ channel<int&, void, int&> ret_int3_chan() {
     global_int = 71;
     co_yield global_int;
     // Should not compile:
-    // co_yield 0;
+    // co_yield 71;
     global_int = 42;
     co_return global_int;
 }
@@ -80,7 +132,10 @@ TEST_CASE("Reference yield") {
     CHECK(io.return_value() == 42);
 }
 
-channel<int> inner() { co_yield 31; }
+channel<int> inner() {
+    co_yield 31;
+    co_yield 8;
+}
 channel<int> outer() {
     co_yield global_int;
     co_yield from_channel(inner());
@@ -96,9 +151,36 @@ TEST_CASE("Nested yield") {
     REQUIRE_FALSE(io.done());
     CHECK(io.current() == 31);
     io.send();
+    CHECK(io.current() == 8);
+    io.send();
     CHECK(io.done());
 }
 
+channel<int> more_outerer() {
+    co_yield 4;
+    co_yield *outer();
+    co_yield -4;
+}
+
+TEST_CASE("Deeper nested yield") {
+    global_int = 94;
+    auto ch    = more_outerer();
+    auto io    = ch.open();
+    REQUIRE_FALSE(io.done());
+    CHECK(io.current() == 4);
+    io.send();
+    REQUIRE_FALSE(io.done());
+    CHECK(io.current() == 94);
+    io.send();
+    REQUIRE_FALSE(io.done());
+    CHECK(io.current() == 31);
+    io.send();
+    CHECK(io.current() == 8);
+    io.send();
+    REQUIRE_FALSE(io.done());
+    CHECK(io.current() == -4);
+}
+
 channel<int, void, std::string> inner_with_str() {
     co_yield 31;
     co_return "Howdy";
@@ -177,9 +259,9 @@ channel<> maybe_throw(bool do_throw) {
 }
 channel<> inner_loop() {
     std::vector<int> vec(1024);
-    co_yield ~maybe_throw(false);
-    co_yield ~maybe_throw(true);
-    co_yield ~maybe_throw(false);
+    co_yield *maybe_throw(false);
+    co_yield *maybe_throw(true);
+    co_yield *maybe_throw(false);
 }
 
 channel<> outer_loop() {
@@ -203,7 +285,7 @@ channel<int, int> deep_channel(int layers) {
         CHECK(got == 1729);
     } else {
         co_yield layers;
-        co_yield ~deep_channel(layers - 1);
+        co_yield *deep_channel(layers - 1);
         co_yield layers;
     }
 }
@@ -231,7 +313,7 @@ channel<void, void, int> deep_return(int n, int top) {
     if (n == 0) {
         co_return top;
     }
-    co_return co_yield ~deep_return(n - 1, top);
+    co_return co_yield *deep_return(n - 1, top);
 }
 
 TEST_CASE("Deep return") {
@@ -295,16 +377,62 @@ neo::channel<int> inner_throws() {
 
 neo::channel<int> outer_catches() {
     try {
-        co_yield ~inner_throws();
+        co_yield *inner_throws();
         FAIL("Child did not throw, but we expected it");
     } catch (std::runtime_error const&) {
         co_return;
     }
 }
 
-neo::channel<int> outer_unaware() { co_yield ~outer_catches(); }
+neo::channel<int> outer_unaware() { co_yield *outer_catches(); }
 
 TEST_CASE("Nested throw") {
     auto ch = outer_unaware();
     CHECK_NOTHROW(ch.open());
-}
\ No newline at end of file
+}
+
+struct ref_conversion {
+    static channel<std::string&> get_strings() {
+        std::string s = "Joe";
+        co_yield s;
+    }
+    static channel<std::string> get_string_values() {
+        co_yield "value-string";  //
+    }
+    static channel<const char*> get_cstrings() {
+        co_yield "c-string";  //
+    }
+    static channel<const char* const&> get_cstrings_cref() {
+        co_yield "c-string-cref";  //
+    }
+    static channel<int&> get_integers() {
+        int i = 21;
+        co_yield i;
+    }
+    static channel<const std::string&> get_strings_const() {
+        std::string s = "Hello";
+        co_yield s;
+        auto co = get_strings();  // Adds const
+        //* Should not compile: All will create a temporary-bound reference:
+        // co_yield *get_cstrings();
+        // co_yield *get_cstrings_cref();
+        // co_yield *get_string_values();
+        //* Should not compile: Cannot convert an int& to a const std::string&
+        // co_yield *get_integers();
+        //* Should not compile: Would create a temporary-bound reference from the string literal
+        // co_yield "bad";
+        co_yield *co;
+        s = "fin";
+        co_yield s;
+    }
+};
+
+TEST_CASE("Reference conversion") {
+    auto ch = ref_conversion::get_strings_const();
+    auto io = ch.open();
+    CHECK(io.current() == "Hello");
+    io.send();
+    CHECK(io.current() == "Joe");
+    io.send();
+    CHECK(io.current() == "fin");
+}
diff --git a/src/neo/channel_fwd.hpp b/src/neo/channel_fwd.hpp
index eddb00f..39b2e8c 100644
--- a/src/neo/channel_fwd.hpp
+++ b/src/neo/channel_fwd.hpp
@@ -2,28 +2,6 @@
 
 namespace neo {
 
-/**
- * @brief A bidirectional communication channel coroutine type.
- *
- * @tparam Yield The type that will be produced by the coroutine, accessed using the `current()`
- *      method.
- * @tparam Send The type that will be sent to the coroutine, delivered by the `send` method, and
- *      the return value of plain co_yield expressions
- * @tparam Return The type that should be co_returned from the coroutine. Accessible
- *      from the invoker as the `return_value()` method.
- *
- * Any of the above template parameters may be `void`, with the following notes:
- *
- * • If the `Yield` parameter is void, then the `co_yield` expressions must yield
- *   a literal zero "0", and the `current()` method will return void.
- * • If the `Send` parameter is void, then the `co_yield` expression will have
- *   type `void`, and `send()` must be called with no arguments.
- * • If the `Return` parameter is void, then the `return_value()` function will
- *   also have a return type of `void`.
- *
- * Channel coroutines may also co_yield other channels, using the `from_channel`
- * wrapper.
- */
 template <typename Yield = void, typename Send = void, typename Return = void>
 class channel;
 
@@ -43,14 +21,4 @@ class channel_pipe;
 template <typename C>
 class from_channel;
 
-namespace _channel_detail {
-
-template <typename Y, typename S, typename R>
-class promise;
-
-template <typename, typename>
-struct promise_base;
-
-}  // namespace _channel_detail
-
 }  // namespace neo
diff --git a/src/neo/compare.hpp b/src/neo/compare.hpp
new file mode 100644
index 0000000..5251b3f
--- /dev/null
+++ b/src/neo/compare.hpp
@@ -0,0 +1,51 @@
+#pragma once
+
+#include "neo/attrib.hpp"
+#include "neo/declval.hpp"
+#include <neo/concepts.hpp>
+
+#include <compare>
+
+namespace neo {
+
+struct synth_three_way_fn {
+    template <typename T, three_way_comparable_with<T> U>
+    NEO_ALWAYS_INLINE constexpr std::compare_three_way_result_t<T, U>
+    operator()(const T& t, const U& u) const noexcept {
+        return t <=> u;
+    }
+
+    template <typename T, typename U>
+        requires(not three_way_comparable_with<T, U>)
+    constexpr std::weak_ordering operator()(const T& t, const T& u) noexcept
+        requires requires {
+            { t < u } -> simple_boolean;
+            { u < t } -> simple_boolean;
+        }
+    {
+        if (t < u) {
+            return std::weak_ordering::less;
+        } else if (u < t) {
+            return std::weak_ordering::greater;
+        }
+        return std::weak_ordering::equivalent;
+    }
+};
+
+/**
+ * @brief A binary-invocable object that performs an effective three-way comparison
+ * between two objects of arbitrary type. It is only requires that the objects
+ * be less-than comparable.
+ *
+ * If a full `operator<=>` is available, it will be used, otherwise a `std::weak_ordering`
+ * will be generated by two calls to `operator<`.
+ *
+ * Based on the exposition-only `synth-three-way` used throughout the standard library.
+ */
+inline constexpr synth_three_way_fn synth_three_way;
+
+template <typename T, typename U>
+using synth_three_way_result_t
+    = decltype(synth_three_way(NEO_DECLVAL(T const&), NEO_DECLVAL(U const&)));
+
+}  // namespace neo
\ No newline at end of file
diff --git a/src/neo/concepts.hpp b/src/neo/concepts.hpp
index 64a8a68..fed9f00 100644
--- a/src/neo/concepts.hpp
+++ b/src/neo/concepts.hpp
@@ -2,6 +2,7 @@
 
 #include "./fwd.hpp"
 #include "./invoke.hpp"
+#include "./swap.hpp"
 #include "./type_traits.hpp"
 #include "./version.hpp"
 
@@ -44,7 +45,12 @@ concept destructible = requires {
 template <typename T, typename... Args>
 concept constructible_from =
         destructible<T>
-    and requires(Args&&... args) { T(NEO_FWD(args)...); }
+    and requires(Args&&... args) { T((Args&&)(args)...); }
+    #if NEO_HAS_BUILTIN(__is_constructible)
+    and __is_constructible(T, Args...)
+    #else
+    and std::is_constructible_v<T, Args...>
+    #endif
     ;
 
 /// Check whether one can static_cast<To>(From)
@@ -249,7 +255,9 @@ concept swappable_with = detail::swappable_impl<T, U>;
  * @brief Test whether a type is swappable with itself via std::ranges::swap
  */
 template <typename T>
-concept swappable = detail::can_std_ranges_swap<T&, T&>;
+concept swappable = requires(T& t) {
+    neo::swap(t, t);
+} or detail::can_std_ranges_swap<T&, T&>;
 
 namespace detail {
 
@@ -408,9 +416,20 @@ concept nothrow_constructible_from =
 #endif
     ;
 
+template <typename T>
+concept move_assignable =
+        move_constructible<T>
+    and assignable_from<T&, T&&>;
+
+template <typename T>
+concept copy_assignable =
+        move_assignable<T>
+    and copy_constructible<T>
+    and assignable_from<T&, const T&>;
+
 template <typename T, typename... Args>
 concept trivially_constructible =
-        constructible_from<T, Args...>
+        nothrow_constructible_from<T, Args...>
     and neo_is_trivially_constructible(T, Args...);
 
 template <typename T>
@@ -428,15 +447,36 @@ concept trivially_assignable =
         assignable_from<To, From>
     and neo_is_trivially_assignable(To, From);
 
+template <typename T>
+concept trivially_move_constructible =
+        move_constructible<T>
+    and trivially_constructible<T, T&&>;
+
+template <typename T>
+concept trivially_copy_constructible =
+        copy_constructible<T>
+    and trivially_constructible<T, const T&>;
+
+template <typename T>
+concept trivially_copy_assignable =
+        copy_assignable<T>
+    and trivially_assignable<T&, T const&>;
+
+template <typename T>
+concept trivially_move_assignable =
+        move_assignable<T>
+    and trivially_assignable<T&, T&&>;
+
 template <typename T>
 concept trivially_movable =
         movable<T>
-    and trivially_constructible<T, T&&>
+    and trivially_move_constructible<T>
     and trivially_assignable<T&, T&&>;
 
 template <typename T>
 concept trivially_copyable =
         copyable<T>
+    and trivially_copy_constructible<T>
     and trivially_movable<T>
     and neo_is_trivially_copyayable(T)
     ;
@@ -451,17 +491,55 @@ concept nothrow_invocable =
         { neo::invoke(NEO_FWD(fn), NEO_FWD(args)...) } noexcept;
     };
 
-template <typename T>
-concept move_assignable =
-        move_constructible<T>
-    and assignable_from<T&, T&&>;
+namespace detail {
 
 template <typename T>
-concept copy_assignable =
-        move_assignable<T>
-    and copy_constructible<T>
-    and assignable_from<T&, const T&>;
+struct narrowing_conversion_helper {
+    T one[1];
+};
+
+} // namespace detail
+
+/**
+ * @brief Check that `From` is convertible to `To` without causing built-in
+ * narrowing.
+ */
+template <typename From, typename To>
+concept non_narrowing_convertible_to =
+        convertible_to<From, To>
+    and requires(From&& from) {
+        // This expression will be invalid if the conversion of `From` to `To`
+        // causes narrowing, because such conversion appears within a braced initializer
+        detail::narrowing_conversion_helper<remove_cvref_t<To>>{{NEO_FWD(from)}};
+    };
 
 // clang-format on
 
+namespace detail {
+
+template <typename Reference, typename From>
+concept best_guest_ref_from_tmp =
+    // If we can convert From* to Reference*, then there's a safe derived->base conversion
+    // that will not create a temporary
+    not convertible_to<add_pointer_t<From>, add_pointer_t<Reference>>
+    // If we can convert to the reference' value type, then a conversion might occur
+    and constructible_from<remove_cvref_t<Reference>, From>
+    // And if a reference can bind to an rvalue of the value type, then that's going to
+    // be the temporary binding we want to avoid
+    and constructible_from<Reference, add_rvalue_reference_t<remove_cvref_t<Reference>>>;
+
+}  // namespace detail
+
+#if NEO_HAS_BUILTIN(__reference_constructs_from_temporary)
+template <typename Reference, typename From>
+concept reference_constructible_from_temporary
+    = __reference_constructs_from_temporary(Reference, From);
+#else
+template <typename Reference, typename From>
+concept reference_constructible_from_temporary  //
+    = reference_type<Reference>                 //
+    and constructible_from<Reference, From>     //
+    and detail::best_guest_ref_from_tmp<Reference, From>;
+#endif
+
 }  // namespace neo
diff --git a/src/neo/concepts.test.cpp b/src/neo/concepts.test.cpp
index 0db2f1e..00e61ca 100644
--- a/src/neo/concepts.test.cpp
+++ b/src/neo/concepts.test.cpp
@@ -179,4 +179,24 @@ std::false_type test_trivially_copyable_subsume(T);
 
 static_assert(decltype(test_trivially_copyable_subsume(5))::value);
 
+static_assert(non_narrowing_convertible_to<float, double>);
+static_assert(not non_narrowing_convertible_to<const char*, bool>);
+static_assert(non_narrowing_convertible_to<bool, int>);
+static_assert(not non_narrowing_convertible_to<int, bool>);
+static_assert(not non_narrowing_convertible_to<signed, unsigned>);
+static_assert(non_narrowing_convertible_to<unsigned short, signed int>);
+
 static_assert(destructible<int&>);
+
+TEST_CASE("reference_constructible_from_temporary") {
+    STATIC_REQUIRE(not reference_constructible_from_temporary<int, int>);
+    STATIC_REQUIRE(not reference_constructible_from_temporary<int&, int>);
+    STATIC_REQUIRE(not reference_constructible_from_temporary<int&, int&>);
+    STATIC_REQUIRE(not reference_constructible_from_temporary<int&, const int&>);
+    STATIC_REQUIRE(not reference_constructible_from_temporary<const int&, const int&>);
+    STATIC_REQUIRE(reference_constructible_from_temporary<const int&, const long&>);
+    STATIC_REQUIRE(reference_constructible_from_temporary<const std::string&, const char*>);
+    STATIC_REQUIRE(reference_constructible_from_temporary<std::string&&, const char*>);
+    STATIC_REQUIRE(not reference_constructible_from_temporary<std::string&, const char*>);
+    STATIC_REQUIRE(not reference_constructible_from_temporary<std::string, const char*>);
+}
diff --git a/src/neo/constexpr_union.hpp b/src/neo/constexpr_union.hpp
new file mode 100644
index 0000000..2021682
--- /dev/null
+++ b/src/neo/constexpr_union.hpp
@@ -0,0 +1,16139 @@
+#pragma once
+
+// clang-format off
+
+// d8888b.  .d88b.       d8b   db  .d88b.  d888888b      d88888b d8888b. d888888b d888888b
+// 88  `8D .8P  Y8.      888o  88 .8P  Y8. `~~88~~'      88'     88  `8D   `88'   `~~88~~'
+// 88   88 88    88      88V8o 88 88    88    88         88ooooo 88   88    88       88
+// 88   88 88    88      88 V8o88 88    88    88         88~~~~~ 88   88    88       88
+// 88  .8D `8b  d8'      88  V888 `8b  d8'    88         88.     88  .8D   .88.      88
+// Y8888D'  `Y88P'       VP   V8P  `Y88P'     YP         Y88888P Y8888D' Y888888P    YP
+
+// This file was GENERATED from src/neo/constexpr_union.hpp.jinja
+
+#include <neo/unit.hpp>
+#include <neo/attrib.hpp>
+#include <neo/addressof.hpp>
+#include <neo/meta.hpp>
+#include <neo/type_traits.hpp>
+#include <neo/fwd.hpp>
+
+#include <memory>  // std::construct_at
+
+namespace neo {
+
+/**
+ * @brief A variadic union template that is default-constructible and `constexpr`-ready.
+ *
+ * Defines three member function templates:
+ *
+ * - `get<N>() -> nth_type<N> [const] [&|&&]` obtain a reference to the `Nth` union member.
+ * - `construct<N>(auto&&...) -> nth_type<N>&` activate the `Nth` union member by calling
+ *   the constructor with the given arguments. No other union members are modified.
+ * - `destroy<N>() -> void` - Destroy the `Nth` union member by calling its destructor.
+ *
+ * Every specialization of `constexpr_union` constains a `nil` alternative which is
+ * activated upon default-construction of the union. The names of the variadic members are
+ * the zero-based index of the member with an underscore prefix (e.g. `_0`, `_1`, `_2`, `_3`).
+ * To access the `Nth` member generically, use the `get<N>()` member function template, which
+ * returns a reference to that member with the cvref-qualifiers of the instance used to call the
+ * `get` member. To get the `Nth` type of the union, use the `nth_type<N>` member alias
+ * template.
+ *
+ * The union is not a "`variant`"": it is up to the user to track the active member and
+ * to correctly call the constructors/destructors when needed. The sole purpose of
+ * this class template is to simplify the implementation of `variant`/`optional`-style
+ * class templates.
+ *
+ * Because of the implicit `nil` member, a `constexpr_union<T>` can be used as storage
+ * for an optional `T`, with the `nil` member acting as a the "null" state.
+ *
+ * All union members are marked with `[[no_uninque_address]]`.
+ *
+ * @tparam Ts... The alternative of the union. Must not be empty.
+ */
+template <typename... Ts>
+union constexpr_union;
+
+namespace detail {
+
+template <typename... Ts>
+concept all_trivially_destructible =
+    (neo_is_trivially_destructible(Ts) and ... and true);
+
+template <std::size_t N, typename Ret, typename Onion>
+NEO_ALWAYS_INLINE constexpr Ret get_member(Onion&& on) noexcept {
+    if constexpr (N == 0) return static_cast<Ret>(on._0);
+    if constexpr (N == 1) return static_cast<Ret>(on._1);
+    if constexpr (N == 2) return static_cast<Ret>(on._2);
+    if constexpr (N == 3) return static_cast<Ret>(on._3);
+    if constexpr (N == 4) return static_cast<Ret>(on._4);
+    if constexpr (N == 5) return static_cast<Ret>(on._5);
+    if constexpr (N == 6) return static_cast<Ret>(on._6);
+    if constexpr (N == 7) return static_cast<Ret>(on._7);
+    if constexpr (N == 8) return static_cast<Ret>(on._8);
+    if constexpr (N == 9) return static_cast<Ret>(on._9);
+    if constexpr (N == 10) return static_cast<Ret>(on._10);
+    if constexpr (N == 11) return static_cast<Ret>(on._11);
+    if constexpr (N == 12) return static_cast<Ret>(on._12);
+    if constexpr (N == 13) return static_cast<Ret>(on._13);
+    if constexpr (N == 14) return static_cast<Ret>(on._14);
+    if constexpr (N == 15) return static_cast<Ret>(on._15);
+    if constexpr (N == 16) return static_cast<Ret>(on._16);
+    if constexpr (N == 17) return static_cast<Ret>(on._17);
+    if constexpr (N == 18) return static_cast<Ret>(on._18);
+    if constexpr (N == 19) return static_cast<Ret>(on._19);
+    if constexpr (N == 20) return static_cast<Ret>(on._20);
+    if constexpr (N == 21) return static_cast<Ret>(on._21);
+    if constexpr (N == 22) return static_cast<Ret>(on._22);
+    if constexpr (N == 23) return static_cast<Ret>(on._23);
+    if constexpr (N == 24) return static_cast<Ret>(on._24);
+    if constexpr (N == 25) return static_cast<Ret>(on._25);
+    if constexpr (N == 26) return static_cast<Ret>(on._26);
+    if constexpr (N == 27) return static_cast<Ret>(on._27);
+    if constexpr (N == 28) return static_cast<Ret>(on._28);
+    if constexpr (N == 29) return static_cast<Ret>(on._29);
+    if constexpr (N == 30) return static_cast<Ret>(on._30);
+    if constexpr (N == 31) return static_cast<Ret>(on._31);
+    if constexpr (N == 32) return static_cast<Ret>(on._32);
+    if constexpr (N == 33) return static_cast<Ret>(on._33);
+    if constexpr (N == 34) return static_cast<Ret>(on._34);
+    if constexpr (N == 35) return static_cast<Ret>(on._35);
+    if constexpr (N == 36) return static_cast<Ret>(on._36);
+    if constexpr (N == 37) return static_cast<Ret>(on._37);
+    if constexpr (N == 38) return static_cast<Ret>(on._38);
+    if constexpr (N == 39) return static_cast<Ret>(on._39);
+    if constexpr (N == 40) return static_cast<Ret>(on._40);
+    if constexpr (N == 41) return static_cast<Ret>(on._41);
+    if constexpr (N == 42) return static_cast<Ret>(on._42);
+    if constexpr (N == 43) return static_cast<Ret>(on._43);
+    if constexpr (N == 44) return static_cast<Ret>(on._44);
+    if constexpr (N == 45) return static_cast<Ret>(on._45);
+    if constexpr (N == 46) return static_cast<Ret>(on._46);
+    if constexpr (N == 47) return static_cast<Ret>(on._47);
+    if constexpr (N == 48) return static_cast<Ret>(on._48);
+    if constexpr (N == 49) return static_cast<Ret>(on._49);
+    if constexpr (N == 50) return static_cast<Ret>(on._50);
+    if constexpr (N == 51) return static_cast<Ret>(on._51);
+    if constexpr (N == 52) return static_cast<Ret>(on._52);
+    if constexpr (N == 53) return static_cast<Ret>(on._53);
+    if constexpr (N == 54) return static_cast<Ret>(on._54);
+    if constexpr (N == 55) return static_cast<Ret>(on._55);
+    if constexpr (N == 56) return static_cast<Ret>(on._56);
+    if constexpr (N == 57) return static_cast<Ret>(on._57);
+    if constexpr (N == 58) return static_cast<Ret>(on._58);
+    if constexpr (N == 59) return static_cast<Ret>(on._59);
+    if constexpr (N == 60) return static_cast<Ret>(on._60);
+    if constexpr (N == 61) return static_cast<Ret>(on._61);
+    if constexpr (N == 62) return static_cast<Ret>(on._62);
+    if constexpr (N == 63) return static_cast<Ret>(on._63);
+    if constexpr (N == 64) return static_cast<Ret>(on._64);
+    if constexpr (N == 65) return static_cast<Ret>(on._65);
+    if constexpr (N == 66) return static_cast<Ret>(on._66);
+    if constexpr (N == 67) return static_cast<Ret>(on._67);
+    if constexpr (N == 68) return static_cast<Ret>(on._68);
+    if constexpr (N == 69) return static_cast<Ret>(on._69);
+    if constexpr (N == 70) return static_cast<Ret>(on._70);
+    if constexpr (N == 71) return static_cast<Ret>(on._71);
+    if constexpr (N == 72) return static_cast<Ret>(on._72);
+    if constexpr (N == 73) return static_cast<Ret>(on._73);
+    if constexpr (N == 74) return static_cast<Ret>(on._74);
+    if constexpr (N == 75) return static_cast<Ret>(on._75);
+    if constexpr (N == 76) return static_cast<Ret>(on._76);
+    if constexpr (N == 77) return static_cast<Ret>(on._77);
+    if constexpr (N == 78) return static_cast<Ret>(on._78);
+    if constexpr (N == 79) return static_cast<Ret>(on._79);
+    if constexpr (N == 80) return static_cast<Ret>(on._80);
+    if constexpr (N == 81) return static_cast<Ret>(on._81);
+    if constexpr (N == 82) return static_cast<Ret>(on._82);
+    if constexpr (N == 83) return static_cast<Ret>(on._83);
+    if constexpr (N == 84) return static_cast<Ret>(on._84);
+    if constexpr (N == 85) return static_cast<Ret>(on._85);
+    if constexpr (N == 86) return static_cast<Ret>(on._86);
+    if constexpr (N == 87) return static_cast<Ret>(on._87);
+    if constexpr (N == 88) return static_cast<Ret>(on._88);
+    if constexpr (N == 89) return static_cast<Ret>(on._89);
+    if constexpr (N == 90) return static_cast<Ret>(on._90);
+    if constexpr (N == 91) return static_cast<Ret>(on._91);
+    if constexpr (N == 92) return static_cast<Ret>(on._92);
+    if constexpr (N == 93) return static_cast<Ret>(on._93);
+    if constexpr (N == 94) return static_cast<Ret>(on._94);
+    if constexpr (N == 95) return static_cast<Ret>(on._95);
+    if constexpr (N == 96) return static_cast<Ret>(on._96);
+    if constexpr (N == 97) return static_cast<Ret>(on._97);
+    if constexpr (N == 98) return static_cast<Ret>(on._98);
+    if constexpr (N == 99) return static_cast<Ret>(on._99);
+}
+
+template <std::size_t N, typename Onion, typename... Args>
+NEO_ALWAYS_INLINE constexpr auto construct_member(Onion& on, Args&&... args) {
+    if constexpr (N == 0) return std::construct_at(NEO_ADDRESSOF(on._0), static_cast<Args&&>(args)...);
+    if constexpr (N == 1) return std::construct_at(NEO_ADDRESSOF(on._1), static_cast<Args&&>(args)...);
+    if constexpr (N == 2) return std::construct_at(NEO_ADDRESSOF(on._2), static_cast<Args&&>(args)...);
+    if constexpr (N == 3) return std::construct_at(NEO_ADDRESSOF(on._3), static_cast<Args&&>(args)...);
+    if constexpr (N == 4) return std::construct_at(NEO_ADDRESSOF(on._4), static_cast<Args&&>(args)...);
+    if constexpr (N == 5) return std::construct_at(NEO_ADDRESSOF(on._5), static_cast<Args&&>(args)...);
+    if constexpr (N == 6) return std::construct_at(NEO_ADDRESSOF(on._6), static_cast<Args&&>(args)...);
+    if constexpr (N == 7) return std::construct_at(NEO_ADDRESSOF(on._7), static_cast<Args&&>(args)...);
+    if constexpr (N == 8) return std::construct_at(NEO_ADDRESSOF(on._8), static_cast<Args&&>(args)...);
+    if constexpr (N == 9) return std::construct_at(NEO_ADDRESSOF(on._9), static_cast<Args&&>(args)...);
+    if constexpr (N == 10) return std::construct_at(NEO_ADDRESSOF(on._10), static_cast<Args&&>(args)...);
+    if constexpr (N == 11) return std::construct_at(NEO_ADDRESSOF(on._11), static_cast<Args&&>(args)...);
+    if constexpr (N == 12) return std::construct_at(NEO_ADDRESSOF(on._12), static_cast<Args&&>(args)...);
+    if constexpr (N == 13) return std::construct_at(NEO_ADDRESSOF(on._13), static_cast<Args&&>(args)...);
+    if constexpr (N == 14) return std::construct_at(NEO_ADDRESSOF(on._14), static_cast<Args&&>(args)...);
+    if constexpr (N == 15) return std::construct_at(NEO_ADDRESSOF(on._15), static_cast<Args&&>(args)...);
+    if constexpr (N == 16) return std::construct_at(NEO_ADDRESSOF(on._16), static_cast<Args&&>(args)...);
+    if constexpr (N == 17) return std::construct_at(NEO_ADDRESSOF(on._17), static_cast<Args&&>(args)...);
+    if constexpr (N == 18) return std::construct_at(NEO_ADDRESSOF(on._18), static_cast<Args&&>(args)...);
+    if constexpr (N == 19) return std::construct_at(NEO_ADDRESSOF(on._19), static_cast<Args&&>(args)...);
+    if constexpr (N == 20) return std::construct_at(NEO_ADDRESSOF(on._20), static_cast<Args&&>(args)...);
+    if constexpr (N == 21) return std::construct_at(NEO_ADDRESSOF(on._21), static_cast<Args&&>(args)...);
+    if constexpr (N == 22) return std::construct_at(NEO_ADDRESSOF(on._22), static_cast<Args&&>(args)...);
+    if constexpr (N == 23) return std::construct_at(NEO_ADDRESSOF(on._23), static_cast<Args&&>(args)...);
+    if constexpr (N == 24) return std::construct_at(NEO_ADDRESSOF(on._24), static_cast<Args&&>(args)...);
+    if constexpr (N == 25) return std::construct_at(NEO_ADDRESSOF(on._25), static_cast<Args&&>(args)...);
+    if constexpr (N == 26) return std::construct_at(NEO_ADDRESSOF(on._26), static_cast<Args&&>(args)...);
+    if constexpr (N == 27) return std::construct_at(NEO_ADDRESSOF(on._27), static_cast<Args&&>(args)...);
+    if constexpr (N == 28) return std::construct_at(NEO_ADDRESSOF(on._28), static_cast<Args&&>(args)...);
+    if constexpr (N == 29) return std::construct_at(NEO_ADDRESSOF(on._29), static_cast<Args&&>(args)...);
+    if constexpr (N == 30) return std::construct_at(NEO_ADDRESSOF(on._30), static_cast<Args&&>(args)...);
+    if constexpr (N == 31) return std::construct_at(NEO_ADDRESSOF(on._31), static_cast<Args&&>(args)...);
+    if constexpr (N == 32) return std::construct_at(NEO_ADDRESSOF(on._32), static_cast<Args&&>(args)...);
+    if constexpr (N == 33) return std::construct_at(NEO_ADDRESSOF(on._33), static_cast<Args&&>(args)...);
+    if constexpr (N == 34) return std::construct_at(NEO_ADDRESSOF(on._34), static_cast<Args&&>(args)...);
+    if constexpr (N == 35) return std::construct_at(NEO_ADDRESSOF(on._35), static_cast<Args&&>(args)...);
+    if constexpr (N == 36) return std::construct_at(NEO_ADDRESSOF(on._36), static_cast<Args&&>(args)...);
+    if constexpr (N == 37) return std::construct_at(NEO_ADDRESSOF(on._37), static_cast<Args&&>(args)...);
+    if constexpr (N == 38) return std::construct_at(NEO_ADDRESSOF(on._38), static_cast<Args&&>(args)...);
+    if constexpr (N == 39) return std::construct_at(NEO_ADDRESSOF(on._39), static_cast<Args&&>(args)...);
+    if constexpr (N == 40) return std::construct_at(NEO_ADDRESSOF(on._40), static_cast<Args&&>(args)...);
+    if constexpr (N == 41) return std::construct_at(NEO_ADDRESSOF(on._41), static_cast<Args&&>(args)...);
+    if constexpr (N == 42) return std::construct_at(NEO_ADDRESSOF(on._42), static_cast<Args&&>(args)...);
+    if constexpr (N == 43) return std::construct_at(NEO_ADDRESSOF(on._43), static_cast<Args&&>(args)...);
+    if constexpr (N == 44) return std::construct_at(NEO_ADDRESSOF(on._44), static_cast<Args&&>(args)...);
+    if constexpr (N == 45) return std::construct_at(NEO_ADDRESSOF(on._45), static_cast<Args&&>(args)...);
+    if constexpr (N == 46) return std::construct_at(NEO_ADDRESSOF(on._46), static_cast<Args&&>(args)...);
+    if constexpr (N == 47) return std::construct_at(NEO_ADDRESSOF(on._47), static_cast<Args&&>(args)...);
+    if constexpr (N == 48) return std::construct_at(NEO_ADDRESSOF(on._48), static_cast<Args&&>(args)...);
+    if constexpr (N == 49) return std::construct_at(NEO_ADDRESSOF(on._49), static_cast<Args&&>(args)...);
+    if constexpr (N == 50) return std::construct_at(NEO_ADDRESSOF(on._50), static_cast<Args&&>(args)...);
+    if constexpr (N == 51) return std::construct_at(NEO_ADDRESSOF(on._51), static_cast<Args&&>(args)...);
+    if constexpr (N == 52) return std::construct_at(NEO_ADDRESSOF(on._52), static_cast<Args&&>(args)...);
+    if constexpr (N == 53) return std::construct_at(NEO_ADDRESSOF(on._53), static_cast<Args&&>(args)...);
+    if constexpr (N == 54) return std::construct_at(NEO_ADDRESSOF(on._54), static_cast<Args&&>(args)...);
+    if constexpr (N == 55) return std::construct_at(NEO_ADDRESSOF(on._55), static_cast<Args&&>(args)...);
+    if constexpr (N == 56) return std::construct_at(NEO_ADDRESSOF(on._56), static_cast<Args&&>(args)...);
+    if constexpr (N == 57) return std::construct_at(NEO_ADDRESSOF(on._57), static_cast<Args&&>(args)...);
+    if constexpr (N == 58) return std::construct_at(NEO_ADDRESSOF(on._58), static_cast<Args&&>(args)...);
+    if constexpr (N == 59) return std::construct_at(NEO_ADDRESSOF(on._59), static_cast<Args&&>(args)...);
+    if constexpr (N == 60) return std::construct_at(NEO_ADDRESSOF(on._60), static_cast<Args&&>(args)...);
+    if constexpr (N == 61) return std::construct_at(NEO_ADDRESSOF(on._61), static_cast<Args&&>(args)...);
+    if constexpr (N == 62) return std::construct_at(NEO_ADDRESSOF(on._62), static_cast<Args&&>(args)...);
+    if constexpr (N == 63) return std::construct_at(NEO_ADDRESSOF(on._63), static_cast<Args&&>(args)...);
+    if constexpr (N == 64) return std::construct_at(NEO_ADDRESSOF(on._64), static_cast<Args&&>(args)...);
+    if constexpr (N == 65) return std::construct_at(NEO_ADDRESSOF(on._65), static_cast<Args&&>(args)...);
+    if constexpr (N == 66) return std::construct_at(NEO_ADDRESSOF(on._66), static_cast<Args&&>(args)...);
+    if constexpr (N == 67) return std::construct_at(NEO_ADDRESSOF(on._67), static_cast<Args&&>(args)...);
+    if constexpr (N == 68) return std::construct_at(NEO_ADDRESSOF(on._68), static_cast<Args&&>(args)...);
+    if constexpr (N == 69) return std::construct_at(NEO_ADDRESSOF(on._69), static_cast<Args&&>(args)...);
+    if constexpr (N == 70) return std::construct_at(NEO_ADDRESSOF(on._70), static_cast<Args&&>(args)...);
+    if constexpr (N == 71) return std::construct_at(NEO_ADDRESSOF(on._71), static_cast<Args&&>(args)...);
+    if constexpr (N == 72) return std::construct_at(NEO_ADDRESSOF(on._72), static_cast<Args&&>(args)...);
+    if constexpr (N == 73) return std::construct_at(NEO_ADDRESSOF(on._73), static_cast<Args&&>(args)...);
+    if constexpr (N == 74) return std::construct_at(NEO_ADDRESSOF(on._74), static_cast<Args&&>(args)...);
+    if constexpr (N == 75) return std::construct_at(NEO_ADDRESSOF(on._75), static_cast<Args&&>(args)...);
+    if constexpr (N == 76) return std::construct_at(NEO_ADDRESSOF(on._76), static_cast<Args&&>(args)...);
+    if constexpr (N == 77) return std::construct_at(NEO_ADDRESSOF(on._77), static_cast<Args&&>(args)...);
+    if constexpr (N == 78) return std::construct_at(NEO_ADDRESSOF(on._78), static_cast<Args&&>(args)...);
+    if constexpr (N == 79) return std::construct_at(NEO_ADDRESSOF(on._79), static_cast<Args&&>(args)...);
+    if constexpr (N == 80) return std::construct_at(NEO_ADDRESSOF(on._80), static_cast<Args&&>(args)...);
+    if constexpr (N == 81) return std::construct_at(NEO_ADDRESSOF(on._81), static_cast<Args&&>(args)...);
+    if constexpr (N == 82) return std::construct_at(NEO_ADDRESSOF(on._82), static_cast<Args&&>(args)...);
+    if constexpr (N == 83) return std::construct_at(NEO_ADDRESSOF(on._83), static_cast<Args&&>(args)...);
+    if constexpr (N == 84) return std::construct_at(NEO_ADDRESSOF(on._84), static_cast<Args&&>(args)...);
+    if constexpr (N == 85) return std::construct_at(NEO_ADDRESSOF(on._85), static_cast<Args&&>(args)...);
+    if constexpr (N == 86) return std::construct_at(NEO_ADDRESSOF(on._86), static_cast<Args&&>(args)...);
+    if constexpr (N == 87) return std::construct_at(NEO_ADDRESSOF(on._87), static_cast<Args&&>(args)...);
+    if constexpr (N == 88) return std::construct_at(NEO_ADDRESSOF(on._88), static_cast<Args&&>(args)...);
+    if constexpr (N == 89) return std::construct_at(NEO_ADDRESSOF(on._89), static_cast<Args&&>(args)...);
+    if constexpr (N == 90) return std::construct_at(NEO_ADDRESSOF(on._90), static_cast<Args&&>(args)...);
+    if constexpr (N == 91) return std::construct_at(NEO_ADDRESSOF(on._91), static_cast<Args&&>(args)...);
+    if constexpr (N == 92) return std::construct_at(NEO_ADDRESSOF(on._92), static_cast<Args&&>(args)...);
+    if constexpr (N == 93) return std::construct_at(NEO_ADDRESSOF(on._93), static_cast<Args&&>(args)...);
+    if constexpr (N == 94) return std::construct_at(NEO_ADDRESSOF(on._94), static_cast<Args&&>(args)...);
+    if constexpr (N == 95) return std::construct_at(NEO_ADDRESSOF(on._95), static_cast<Args&&>(args)...);
+    if constexpr (N == 96) return std::construct_at(NEO_ADDRESSOF(on._96), static_cast<Args&&>(args)...);
+    if constexpr (N == 97) return std::construct_at(NEO_ADDRESSOF(on._97), static_cast<Args&&>(args)...);
+    if constexpr (N == 98) return std::construct_at(NEO_ADDRESSOF(on._98), static_cast<Args&&>(args)...);
+    if constexpr (N == 99) return std::construct_at(NEO_ADDRESSOF(on._99), static_cast<Args&&>(args)...);
+}
+
+template <std::size_t N, typename Onion, typename... Args>
+NEO_ALWAYS_INLINE constexpr void destroy_member(Onion& on) {
+    if constexpr (N == 0) return std::destroy_at(NEO_ADDRESSOF(on._0));
+    if constexpr (N == 1) return std::destroy_at(NEO_ADDRESSOF(on._1));
+    if constexpr (N == 2) return std::destroy_at(NEO_ADDRESSOF(on._2));
+    if constexpr (N == 3) return std::destroy_at(NEO_ADDRESSOF(on._3));
+    if constexpr (N == 4) return std::destroy_at(NEO_ADDRESSOF(on._4));
+    if constexpr (N == 5) return std::destroy_at(NEO_ADDRESSOF(on._5));
+    if constexpr (N == 6) return std::destroy_at(NEO_ADDRESSOF(on._6));
+    if constexpr (N == 7) return std::destroy_at(NEO_ADDRESSOF(on._7));
+    if constexpr (N == 8) return std::destroy_at(NEO_ADDRESSOF(on._8));
+    if constexpr (N == 9) return std::destroy_at(NEO_ADDRESSOF(on._9));
+    if constexpr (N == 10) return std::destroy_at(NEO_ADDRESSOF(on._10));
+    if constexpr (N == 11) return std::destroy_at(NEO_ADDRESSOF(on._11));
+    if constexpr (N == 12) return std::destroy_at(NEO_ADDRESSOF(on._12));
+    if constexpr (N == 13) return std::destroy_at(NEO_ADDRESSOF(on._13));
+    if constexpr (N == 14) return std::destroy_at(NEO_ADDRESSOF(on._14));
+    if constexpr (N == 15) return std::destroy_at(NEO_ADDRESSOF(on._15));
+    if constexpr (N == 16) return std::destroy_at(NEO_ADDRESSOF(on._16));
+    if constexpr (N == 17) return std::destroy_at(NEO_ADDRESSOF(on._17));
+    if constexpr (N == 18) return std::destroy_at(NEO_ADDRESSOF(on._18));
+    if constexpr (N == 19) return std::destroy_at(NEO_ADDRESSOF(on._19));
+    if constexpr (N == 20) return std::destroy_at(NEO_ADDRESSOF(on._20));
+    if constexpr (N == 21) return std::destroy_at(NEO_ADDRESSOF(on._21));
+    if constexpr (N == 22) return std::destroy_at(NEO_ADDRESSOF(on._22));
+    if constexpr (N == 23) return std::destroy_at(NEO_ADDRESSOF(on._23));
+    if constexpr (N == 24) return std::destroy_at(NEO_ADDRESSOF(on._24));
+    if constexpr (N == 25) return std::destroy_at(NEO_ADDRESSOF(on._25));
+    if constexpr (N == 26) return std::destroy_at(NEO_ADDRESSOF(on._26));
+    if constexpr (N == 27) return std::destroy_at(NEO_ADDRESSOF(on._27));
+    if constexpr (N == 28) return std::destroy_at(NEO_ADDRESSOF(on._28));
+    if constexpr (N == 29) return std::destroy_at(NEO_ADDRESSOF(on._29));
+    if constexpr (N == 30) return std::destroy_at(NEO_ADDRESSOF(on._30));
+    if constexpr (N == 31) return std::destroy_at(NEO_ADDRESSOF(on._31));
+    if constexpr (N == 32) return std::destroy_at(NEO_ADDRESSOF(on._32));
+    if constexpr (N == 33) return std::destroy_at(NEO_ADDRESSOF(on._33));
+    if constexpr (N == 34) return std::destroy_at(NEO_ADDRESSOF(on._34));
+    if constexpr (N == 35) return std::destroy_at(NEO_ADDRESSOF(on._35));
+    if constexpr (N == 36) return std::destroy_at(NEO_ADDRESSOF(on._36));
+    if constexpr (N == 37) return std::destroy_at(NEO_ADDRESSOF(on._37));
+    if constexpr (N == 38) return std::destroy_at(NEO_ADDRESSOF(on._38));
+    if constexpr (N == 39) return std::destroy_at(NEO_ADDRESSOF(on._39));
+    if constexpr (N == 40) return std::destroy_at(NEO_ADDRESSOF(on._40));
+    if constexpr (N == 41) return std::destroy_at(NEO_ADDRESSOF(on._41));
+    if constexpr (N == 42) return std::destroy_at(NEO_ADDRESSOF(on._42));
+    if constexpr (N == 43) return std::destroy_at(NEO_ADDRESSOF(on._43));
+    if constexpr (N == 44) return std::destroy_at(NEO_ADDRESSOF(on._44));
+    if constexpr (N == 45) return std::destroy_at(NEO_ADDRESSOF(on._45));
+    if constexpr (N == 46) return std::destroy_at(NEO_ADDRESSOF(on._46));
+    if constexpr (N == 47) return std::destroy_at(NEO_ADDRESSOF(on._47));
+    if constexpr (N == 48) return std::destroy_at(NEO_ADDRESSOF(on._48));
+    if constexpr (N == 49) return std::destroy_at(NEO_ADDRESSOF(on._49));
+    if constexpr (N == 50) return std::destroy_at(NEO_ADDRESSOF(on._50));
+    if constexpr (N == 51) return std::destroy_at(NEO_ADDRESSOF(on._51));
+    if constexpr (N == 52) return std::destroy_at(NEO_ADDRESSOF(on._52));
+    if constexpr (N == 53) return std::destroy_at(NEO_ADDRESSOF(on._53));
+    if constexpr (N == 54) return std::destroy_at(NEO_ADDRESSOF(on._54));
+    if constexpr (N == 55) return std::destroy_at(NEO_ADDRESSOF(on._55));
+    if constexpr (N == 56) return std::destroy_at(NEO_ADDRESSOF(on._56));
+    if constexpr (N == 57) return std::destroy_at(NEO_ADDRESSOF(on._57));
+    if constexpr (N == 58) return std::destroy_at(NEO_ADDRESSOF(on._58));
+    if constexpr (N == 59) return std::destroy_at(NEO_ADDRESSOF(on._59));
+    if constexpr (N == 60) return std::destroy_at(NEO_ADDRESSOF(on._60));
+    if constexpr (N == 61) return std::destroy_at(NEO_ADDRESSOF(on._61));
+    if constexpr (N == 62) return std::destroy_at(NEO_ADDRESSOF(on._62));
+    if constexpr (N == 63) return std::destroy_at(NEO_ADDRESSOF(on._63));
+    if constexpr (N == 64) return std::destroy_at(NEO_ADDRESSOF(on._64));
+    if constexpr (N == 65) return std::destroy_at(NEO_ADDRESSOF(on._65));
+    if constexpr (N == 66) return std::destroy_at(NEO_ADDRESSOF(on._66));
+    if constexpr (N == 67) return std::destroy_at(NEO_ADDRESSOF(on._67));
+    if constexpr (N == 68) return std::destroy_at(NEO_ADDRESSOF(on._68));
+    if constexpr (N == 69) return std::destroy_at(NEO_ADDRESSOF(on._69));
+    if constexpr (N == 70) return std::destroy_at(NEO_ADDRESSOF(on._70));
+    if constexpr (N == 71) return std::destroy_at(NEO_ADDRESSOF(on._71));
+    if constexpr (N == 72) return std::destroy_at(NEO_ADDRESSOF(on._72));
+    if constexpr (N == 73) return std::destroy_at(NEO_ADDRESSOF(on._73));
+    if constexpr (N == 74) return std::destroy_at(NEO_ADDRESSOF(on._74));
+    if constexpr (N == 75) return std::destroy_at(NEO_ADDRESSOF(on._75));
+    if constexpr (N == 76) return std::destroy_at(NEO_ADDRESSOF(on._76));
+    if constexpr (N == 77) return std::destroy_at(NEO_ADDRESSOF(on._77));
+    if constexpr (N == 78) return std::destroy_at(NEO_ADDRESSOF(on._78));
+    if constexpr (N == 79) return std::destroy_at(NEO_ADDRESSOF(on._79));
+    if constexpr (N == 80) return std::destroy_at(NEO_ADDRESSOF(on._80));
+    if constexpr (N == 81) return std::destroy_at(NEO_ADDRESSOF(on._81));
+    if constexpr (N == 82) return std::destroy_at(NEO_ADDRESSOF(on._82));
+    if constexpr (N == 83) return std::destroy_at(NEO_ADDRESSOF(on._83));
+    if constexpr (N == 84) return std::destroy_at(NEO_ADDRESSOF(on._84));
+    if constexpr (N == 85) return std::destroy_at(NEO_ADDRESSOF(on._85));
+    if constexpr (N == 86) return std::destroy_at(NEO_ADDRESSOF(on._86));
+    if constexpr (N == 87) return std::destroy_at(NEO_ADDRESSOF(on._87));
+    if constexpr (N == 88) return std::destroy_at(NEO_ADDRESSOF(on._88));
+    if constexpr (N == 89) return std::destroy_at(NEO_ADDRESSOF(on._89));
+    if constexpr (N == 90) return std::destroy_at(NEO_ADDRESSOF(on._90));
+    if constexpr (N == 91) return std::destroy_at(NEO_ADDRESSOF(on._91));
+    if constexpr (N == 92) return std::destroy_at(NEO_ADDRESSOF(on._92));
+    if constexpr (N == 93) return std::destroy_at(NEO_ADDRESSOF(on._93));
+    if constexpr (N == 94) return std::destroy_at(NEO_ADDRESSOF(on._94));
+    if constexpr (N == 95) return std::destroy_at(NEO_ADDRESSOF(on._95));
+    if constexpr (N == 96) return std::destroy_at(NEO_ADDRESSOF(on._96));
+    if constexpr (N == 97) return std::destroy_at(NEO_ADDRESSOF(on._97));
+    if constexpr (N == 98) return std::destroy_at(NEO_ADDRESSOF(on._98));
+    if constexpr (N == 99) return std::destroy_at(NEO_ADDRESSOF(on._99));
+}
+
+}
+
+template <>
+union constexpr_union<> {
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+};
+
+template <typename T0>
+union constexpr_union<T0> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+};
+
+template <typename T0, typename T1>
+union constexpr_union<T0, T1> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+};
+
+template <typename T0, typename T1, typename T2>
+union constexpr_union<T0, T1, T2> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+};
+
+template <typename T0, typename T1, typename T2, typename T3>
+union constexpr_union<T0, T1, T2, T3> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4>
+union constexpr_union<T0, T1, T2, T3, T4> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5>
+union constexpr_union<T0, T1, T2, T3, T4, T5> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+        else if constexpr (N == 47)
+            return (_47);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+        else if constexpr (N == 47)
+            return (_47);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+        else if constexpr (N == 47)
+            return (_47);
+        else if constexpr (N == 48)
+            return (_48);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+        else if constexpr (N == 47)
+            return (_47);
+        else if constexpr (N == 48)
+            return (_48);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+        else if constexpr (N == 47)
+            return (_47);
+        else if constexpr (N == 48)
+            return (_48);
+        else if constexpr (N == 49)
+            return (_49);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        if constexpr (false) {}
+        else if constexpr (N == 0)
+            return (_0);
+        else if constexpr (N == 1)
+            return (_1);
+        else if constexpr (N == 2)
+            return (_2);
+        else if constexpr (N == 3)
+            return (_3);
+        else if constexpr (N == 4)
+            return (_4);
+        else if constexpr (N == 5)
+            return (_5);
+        else if constexpr (N == 6)
+            return (_6);
+        else if constexpr (N == 7)
+            return (_7);
+        else if constexpr (N == 8)
+            return (_8);
+        else if constexpr (N == 9)
+            return (_9);
+        else if constexpr (N == 10)
+            return (_10);
+        else if constexpr (N == 11)
+            return (_11);
+        else if constexpr (N == 12)
+            return (_12);
+        else if constexpr (N == 13)
+            return (_13);
+        else if constexpr (N == 14)
+            return (_14);
+        else if constexpr (N == 15)
+            return (_15);
+        else if constexpr (N == 16)
+            return (_16);
+        else if constexpr (N == 17)
+            return (_17);
+        else if constexpr (N == 18)
+            return (_18);
+        else if constexpr (N == 19)
+            return (_19);
+        else if constexpr (N == 20)
+            return (_20);
+        else if constexpr (N == 21)
+            return (_21);
+        else if constexpr (N == 22)
+            return (_22);
+        else if constexpr (N == 23)
+            return (_23);
+        else if constexpr (N == 24)
+            return (_24);
+        else if constexpr (N == 25)
+            return (_25);
+        else if constexpr (N == 26)
+            return (_26);
+        else if constexpr (N == 27)
+            return (_27);
+        else if constexpr (N == 28)
+            return (_28);
+        else if constexpr (N == 29)
+            return (_29);
+        else if constexpr (N == 30)
+            return (_30);
+        else if constexpr (N == 31)
+            return (_31);
+        else if constexpr (N == 32)
+            return (_32);
+        else if constexpr (N == 33)
+            return (_33);
+        else if constexpr (N == 34)
+            return (_34);
+        else if constexpr (N == 35)
+            return (_35);
+        else if constexpr (N == 36)
+            return (_36);
+        else if constexpr (N == 37)
+            return (_37);
+        else if constexpr (N == 38)
+            return (_38);
+        else if constexpr (N == 39)
+            return (_39);
+        else if constexpr (N == 40)
+            return (_40);
+        else if constexpr (N == 41)
+            return (_41);
+        else if constexpr (N == 42)
+            return (_42);
+        else if constexpr (N == 43)
+            return (_43);
+        else if constexpr (N == 44)
+            return (_44);
+        else if constexpr (N == 45)
+            return (_45);
+        else if constexpr (N == 46)
+            return (_46);
+        else if constexpr (N == 47)
+            return (_47);
+        else if constexpr (N == 48)
+            return (_48);
+        else if constexpr (N == 49)
+            return (_49);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93, typename T94>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+    NEO_NO_UNIQUE_ADDRESS T94 _94;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93, typename T94, typename T95>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+    NEO_NO_UNIQUE_ADDRESS T94 _94;
+    NEO_NO_UNIQUE_ADDRESS T95 _95;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93, typename T94, typename T95, typename T96>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+    NEO_NO_UNIQUE_ADDRESS T94 _94;
+    NEO_NO_UNIQUE_ADDRESS T95 _95;
+    NEO_NO_UNIQUE_ADDRESS T96 _96;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93, typename T94, typename T95, typename T96, typename T97>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+    NEO_NO_UNIQUE_ADDRESS T94 _94;
+    NEO_NO_UNIQUE_ADDRESS T95 _95;
+    NEO_NO_UNIQUE_ADDRESS T96 _96;
+    NEO_NO_UNIQUE_ADDRESS T97 _97;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93, typename T94, typename T95, typename T96, typename T97, typename T98>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+    NEO_NO_UNIQUE_ADDRESS T94 _94;
+    NEO_NO_UNIQUE_ADDRESS T95 _95;
+    NEO_NO_UNIQUE_ADDRESS T96 _96;
+    NEO_NO_UNIQUE_ADDRESS T97 _97;
+    NEO_NO_UNIQUE_ADDRESS T98 _98;
+};
+
+template <typename T0, typename T1, typename T2, typename T3, typename T4, typename T5, typename T6, typename T7, typename T8, typename T9, typename T10, typename T11, typename T12, typename T13, typename T14, typename T15, typename T16, typename T17, typename T18, typename T19, typename T20, typename T21, typename T22, typename T23, typename T24, typename T25, typename T26, typename T27, typename T28, typename T29, typename T30, typename T31, typename T32, typename T33, typename T34, typename T35, typename T36, typename T37, typename T38, typename T39, typename T40, typename T41, typename T42, typename T43, typename T44, typename T45, typename T46, typename T47, typename T48, typename T49, typename T50, typename T51, typename T52, typename T53, typename T54, typename T55, typename T56, typename T57, typename T58, typename T59, typename T60, typename T61, typename T62, typename T63, typename T64, typename T65, typename T66, typename T67, typename T68, typename T69, typename T70, typename T71, typename T72, typename T73, typename T74, typename T75, typename T76, typename T77, typename T78, typename T79, typename T80, typename T81, typename T82, typename T83, typename T84, typename T85, typename T86, typename T87, typename T88, typename T89, typename T90, typename T91, typename T92, typename T93, typename T94, typename T95, typename T96, typename T97, typename T98, typename T99>
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22, T23, T24, T25, T26, T27, T28, T29, T30, T31, T32, T33, T34, T35, T36, T37, T38, T39, T40, T41, T42, T43, T44, T45, T46, T47, T48, T49, T50, T51, T52, T53, T54, T55, T56, T57, T58, T59, T60, T61, T62, T63, T64, T65, T66, T67, T68, T69, T70, T71, T72, T73, T74, T75, T76, T77, T78, T79, T80, T81, T82, T83, T84, T85, T86, T87, T88, T89, T90, T91, T92, T93, T94, T95, T96, T97, T98, T99>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        return detail::get_member<N, nth_type<N>&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        return detail::get_member<N, nth_type<N> const&>(*this);
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    
+    NEO_NO_UNIQUE_ADDRESS T0 _0;
+    NEO_NO_UNIQUE_ADDRESS T1 _1;
+    NEO_NO_UNIQUE_ADDRESS T2 _2;
+    NEO_NO_UNIQUE_ADDRESS T3 _3;
+    NEO_NO_UNIQUE_ADDRESS T4 _4;
+    NEO_NO_UNIQUE_ADDRESS T5 _5;
+    NEO_NO_UNIQUE_ADDRESS T6 _6;
+    NEO_NO_UNIQUE_ADDRESS T7 _7;
+    NEO_NO_UNIQUE_ADDRESS T8 _8;
+    NEO_NO_UNIQUE_ADDRESS T9 _9;
+    NEO_NO_UNIQUE_ADDRESS T10 _10;
+    NEO_NO_UNIQUE_ADDRESS T11 _11;
+    NEO_NO_UNIQUE_ADDRESS T12 _12;
+    NEO_NO_UNIQUE_ADDRESS T13 _13;
+    NEO_NO_UNIQUE_ADDRESS T14 _14;
+    NEO_NO_UNIQUE_ADDRESS T15 _15;
+    NEO_NO_UNIQUE_ADDRESS T16 _16;
+    NEO_NO_UNIQUE_ADDRESS T17 _17;
+    NEO_NO_UNIQUE_ADDRESS T18 _18;
+    NEO_NO_UNIQUE_ADDRESS T19 _19;
+    NEO_NO_UNIQUE_ADDRESS T20 _20;
+    NEO_NO_UNIQUE_ADDRESS T21 _21;
+    NEO_NO_UNIQUE_ADDRESS T22 _22;
+    NEO_NO_UNIQUE_ADDRESS T23 _23;
+    NEO_NO_UNIQUE_ADDRESS T24 _24;
+    NEO_NO_UNIQUE_ADDRESS T25 _25;
+    NEO_NO_UNIQUE_ADDRESS T26 _26;
+    NEO_NO_UNIQUE_ADDRESS T27 _27;
+    NEO_NO_UNIQUE_ADDRESS T28 _28;
+    NEO_NO_UNIQUE_ADDRESS T29 _29;
+    NEO_NO_UNIQUE_ADDRESS T30 _30;
+    NEO_NO_UNIQUE_ADDRESS T31 _31;
+    NEO_NO_UNIQUE_ADDRESS T32 _32;
+    NEO_NO_UNIQUE_ADDRESS T33 _33;
+    NEO_NO_UNIQUE_ADDRESS T34 _34;
+    NEO_NO_UNIQUE_ADDRESS T35 _35;
+    NEO_NO_UNIQUE_ADDRESS T36 _36;
+    NEO_NO_UNIQUE_ADDRESS T37 _37;
+    NEO_NO_UNIQUE_ADDRESS T38 _38;
+    NEO_NO_UNIQUE_ADDRESS T39 _39;
+    NEO_NO_UNIQUE_ADDRESS T40 _40;
+    NEO_NO_UNIQUE_ADDRESS T41 _41;
+    NEO_NO_UNIQUE_ADDRESS T42 _42;
+    NEO_NO_UNIQUE_ADDRESS T43 _43;
+    NEO_NO_UNIQUE_ADDRESS T44 _44;
+    NEO_NO_UNIQUE_ADDRESS T45 _45;
+    NEO_NO_UNIQUE_ADDRESS T46 _46;
+    NEO_NO_UNIQUE_ADDRESS T47 _47;
+    NEO_NO_UNIQUE_ADDRESS T48 _48;
+    NEO_NO_UNIQUE_ADDRESS T49 _49;
+    NEO_NO_UNIQUE_ADDRESS T50 _50;
+    NEO_NO_UNIQUE_ADDRESS T51 _51;
+    NEO_NO_UNIQUE_ADDRESS T52 _52;
+    NEO_NO_UNIQUE_ADDRESS T53 _53;
+    NEO_NO_UNIQUE_ADDRESS T54 _54;
+    NEO_NO_UNIQUE_ADDRESS T55 _55;
+    NEO_NO_UNIQUE_ADDRESS T56 _56;
+    NEO_NO_UNIQUE_ADDRESS T57 _57;
+    NEO_NO_UNIQUE_ADDRESS T58 _58;
+    NEO_NO_UNIQUE_ADDRESS T59 _59;
+    NEO_NO_UNIQUE_ADDRESS T60 _60;
+    NEO_NO_UNIQUE_ADDRESS T61 _61;
+    NEO_NO_UNIQUE_ADDRESS T62 _62;
+    NEO_NO_UNIQUE_ADDRESS T63 _63;
+    NEO_NO_UNIQUE_ADDRESS T64 _64;
+    NEO_NO_UNIQUE_ADDRESS T65 _65;
+    NEO_NO_UNIQUE_ADDRESS T66 _66;
+    NEO_NO_UNIQUE_ADDRESS T67 _67;
+    NEO_NO_UNIQUE_ADDRESS T68 _68;
+    NEO_NO_UNIQUE_ADDRESS T69 _69;
+    NEO_NO_UNIQUE_ADDRESS T70 _70;
+    NEO_NO_UNIQUE_ADDRESS T71 _71;
+    NEO_NO_UNIQUE_ADDRESS T72 _72;
+    NEO_NO_UNIQUE_ADDRESS T73 _73;
+    NEO_NO_UNIQUE_ADDRESS T74 _74;
+    NEO_NO_UNIQUE_ADDRESS T75 _75;
+    NEO_NO_UNIQUE_ADDRESS T76 _76;
+    NEO_NO_UNIQUE_ADDRESS T77 _77;
+    NEO_NO_UNIQUE_ADDRESS T78 _78;
+    NEO_NO_UNIQUE_ADDRESS T79 _79;
+    NEO_NO_UNIQUE_ADDRESS T80 _80;
+    NEO_NO_UNIQUE_ADDRESS T81 _81;
+    NEO_NO_UNIQUE_ADDRESS T82 _82;
+    NEO_NO_UNIQUE_ADDRESS T83 _83;
+    NEO_NO_UNIQUE_ADDRESS T84 _84;
+    NEO_NO_UNIQUE_ADDRESS T85 _85;
+    NEO_NO_UNIQUE_ADDRESS T86 _86;
+    NEO_NO_UNIQUE_ADDRESS T87 _87;
+    NEO_NO_UNIQUE_ADDRESS T88 _88;
+    NEO_NO_UNIQUE_ADDRESS T89 _89;
+    NEO_NO_UNIQUE_ADDRESS T90 _90;
+    NEO_NO_UNIQUE_ADDRESS T91 _91;
+    NEO_NO_UNIQUE_ADDRESS T92 _92;
+    NEO_NO_UNIQUE_ADDRESS T93 _93;
+    NEO_NO_UNIQUE_ADDRESS T94 _94;
+    NEO_NO_UNIQUE_ADDRESS T95 _95;
+    NEO_NO_UNIQUE_ADDRESS T96 _96;
+    NEO_NO_UNIQUE_ADDRESS T97 _97;
+    NEO_NO_UNIQUE_ADDRESS T98 _98;
+    NEO_NO_UNIQUE_ADDRESS T99 _99;
+};
+
+#if 0
+// In principal, arbitrarily many types could be supported, but some compilers consider it UB to
+// access the tail sub-union if the head sub-union has an active member. GCC accepts, but Clang
+// rejects. This might not have a pretty solution.
+
+// Specialization for at least ten types, which subdivides the arguments into
+// smaller sub-unions.
+template <typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename... More>
+    requires(sizeof...(More) != 0)
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, More...> {
+    using FirstNext = constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+    using Tail = constexpr_union<More...>;
+
+    constexpr constexpr_union(constexpr_union&&)                 = default;
+    constexpr constexpr_union(constexpr_union const&)            = default;
+    constexpr constexpr_union& operator=(constexpr_union&&)      = default;
+    constexpr constexpr_union& operator=(constexpr_union const&) = default;
+
+    constexpr constexpr_union() noexcept
+        : _first_ten() {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires(not neo_is_trivially_destructible(FirstNext)
+              or not neo_is_trivially_destructible(Tail))
+    {}
+
+    template <std::size_t N>
+    using nth_type = meta::at<constexpr_union, N>;
+
+    template <std::size_t N>
+    constexpr nth_type<N>& get() & noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N>
+    constexpr nth_type<N> const& get() const& noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N>
+    constexpr nth_type<N>&& get() && noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N>
+    constexpr nth_type<N> const&& get() const&& noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N, typename... Args>
+    constexpr nth_type<N>&
+    construct(Args&&... args) noexcept(noexcept(nth_type<N>(static_cast<Args&&...>(args)...))) {
+        if constexpr (N < 10) {
+            return _first_ten.template construct<N>(static_cast<Args&&...>(args)...);
+        } else {
+            return _tail.template construct<N - 10>(static_cast<Args&&...>(args)...);
+        }
+    }
+
+    template <std::size_t N>
+        requires requires { typename nth_type<N>; }
+    constexpr void destroy() noexcept {
+        if constexpr (N < 10) {
+            _first_ten.template destroy<N>();
+        } else {
+            _tail.template destroy<N-10>();
+        }
+    }
+
+    NEO_NO_UNIQUE_ADDRESS FirstNext _first_ten;
+    NEO_NO_UNIQUE_ADDRESS Tail _tail;
+};
+
+#endif // disabled
+
+}  // namespace neo
diff --git a/src/neo/constexpr_union.hpp.jinja b/src/neo/constexpr_union.hpp.jinja
new file mode 100644
index 0000000..2019b00
--- /dev/null
+++ b/src/neo/constexpr_union.hpp.jinja
@@ -0,0 +1,276 @@
+#pragma once
+
+// clang-format off
+
+{{generated_file_notice('src/neo/constexpr_union.hpp.jinja')}}
+{#-
+    To render this template, run render.py (at the root of this repo), feeding
+    this file to the script's stdin
+#}
+
+#include <neo/unit.hpp>
+#include <neo/attrib.hpp>
+#include <neo/addressof.hpp>
+#include <neo/meta.hpp>
+#include <neo/type_traits.hpp>
+#include <neo/fwd.hpp>
+
+#include <memory>  // std::construct_at
+
+namespace neo {
+
+/**
+ * @brief A variadic union template that is default-constructible and `constexpr`-ready.
+ *
+ * Defines three member function templates:
+ *
+ * - `get<N>() -> nth_type<N> [const] [&|&&]` obtain a reference to the `Nth` union member.
+ * - `construct<N>(auto&&...) -> nth_type<N>&` activate the `Nth` union member by calling
+ *   the constructor with the given arguments. No other union members are modified.
+ * - `destroy<N>() -> void` - Destroy the `Nth` union member by calling its destructor.
+ *
+ * Every specialization of `constexpr_union` constains a `nil` alternative which is
+ * activated upon default-construction of the union. The names of the variadic members are
+ * the zero-based index of the member with an underscore prefix (e.g. `_0`, `_1`, `_2`, `_3`).
+ * To access the `Nth` member generically, use the `get<N>()` member function template, which
+ * returns a reference to that member with the cvref-qualifiers of the instance used to call the
+ * `get` member. To get the `Nth` type of the union, use the `nth_type<N>` member alias
+ * template.
+ *
+ * The union is not a "`variant`"": it is up to the user to track the active member and
+ * to correctly call the constructors/destructors when needed. The sole purpose of
+ * this class template is to simplify the implementation of `variant`/`optional`-style
+ * class templates.
+ *
+ * Because of the implicit `nil` member, a `constexpr_union<T>` can be used as storage
+ * for an optional `T`, with the `nil` member acting as a the "null" state.
+ *
+ * All union members are marked with `[[no_uninque_address]]`.
+ *
+ * @tparam Ts... The alternative of the union. Must not be empty.
+ */
+template <typename... Ts>
+union constexpr_union;
+
+namespace detail {
+
+template <typename... Ts>
+concept all_trivially_destructible =
+    (neo_is_trivially_destructible(Ts) and ... and true);
+
+template <std::size_t N, typename Ret, typename Onion>
+NEO_ALWAYS_INLINE constexpr Ret get_member(Onion&& on) noexcept {
+    {%- for n in range(100) %}
+    if constexpr (N == {{n}}) return static_cast<Ret>(on._{{n}});
+    {%- endfor %}
+}
+
+template <std::size_t N, typename Onion, typename... Args>
+NEO_ALWAYS_INLINE constexpr auto construct_member(Onion& on, Args&&... args) {
+    {%- for n in range(100) %}
+    if constexpr (N == {{n}}) return std::construct_at(NEO_ADDRESSOF(on._{{n}}), static_cast<Args&&>(args)...);
+    {%- endfor %}
+}
+
+template <std::size_t N, typename Onion, typename... Args>
+NEO_ALWAYS_INLINE constexpr void destroy_member(Onion& on) {
+    {%- for n in range(100) %}
+    if constexpr (N == {{n}}) return std::destroy_at(NEO_ADDRESSOF(on._{{n}}));
+    {%- endfor %}
+}
+
+}
+
+template <>
+union constexpr_union<> {
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+};
+
+#% for n in range(1, 100+1)
+template <{{range(n) | format_each('typename T{}') | join(', ')}}>
+union constexpr_union<{{range(n) | format_each('T{}') | join(', ')}}> {
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, {{range(n) | format_each('T{}') | join(', ')}}>;
+
+    NEO_ALWAYS_INLINE constexpr constexpr_union() noexcept
+        : nil()
+    {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires (not detail::all_trivially_destructible<{{range(n) | format_each('T{}') | join(', ')}}>)
+    {}
+
+    template <std::size_t N, typename... Args>
+    NEO_ALWAYS_INLINE constexpr nth_type<N>& construct(Args&&... args)
+        noexcept(noexcept(nth_type<N>(static_cast<Args&&>(args)...)))
+    {
+        return *detail::construct_member<N>(*this, static_cast<Args&&>(args)...);
+    }
+
+    template <std::size_t N, typename T = nth_type<N>>
+    NEO_ALWAYS_INLINE constexpr void destroy() noexcept {
+        detail::destroy_member<N>(*this);
+    }
+
+    {%- macro foreach_member() -%}
+        {% for nth in range(n) -%}
+        {{caller(nth, 'T{}'.format(nth), '_{}'.format(nth))}}
+        {%- endfor %}
+    {%- endmacro %}
+
+    {%- macro getters(cast, T) -%}
+        {%- if n > 50 -%}
+        return detail::get_member<N, {{T}}>(*this);
+        {%- else -%}
+        if constexpr (false) {}
+        {%- call(idx, _type, member) foreach_member() %}
+        else if constexpr (N == {{idx}})
+            return {{cast}}({{member}});
+        {%- endcall -%}
+        {%- endif %}
+    {%- endmacro %}
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>& get() & noexcept {
+        {{ getters('', 'nth_type<N>&') }}
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const& get() const & noexcept {
+        {{ getters('', 'nth_type<N> const&') }}
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N>&& get() && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    template <std::size_t N>
+    [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type<N> const&& get() const && noexcept {
+        return NEO_MOVE(this->get<N>());
+    }
+
+    NEO_NO_UNIQUE_ADDRESS unit nil;
+
+    constexpr_union(constexpr_union&&) = default;
+    constexpr_union(constexpr_union const&) = default;
+    constexpr_union& operator=(constexpr_union&&) = default;
+    constexpr_union& operator=(constexpr_union const&) = default;
+    {# . #}
+
+    {%- call(_, type, name) foreach_member() %}
+    NEO_NO_UNIQUE_ADDRESS {{type}} {{name}};
+    {%- endcall %}
+};
+{##}
+#% endfor
+
+#if 0
+// In principal, arbitrarily many types could be supported, but some compilers consider it UB to
+// access the tail sub-union if the head sub-union has an active member. GCC accepts, but Clang
+// rejects. This might not have a pretty solution.
+
+// Specialization for at least ten types, which subdivides the arguments into
+// smaller sub-unions.
+template <typename T0,
+          typename T1,
+          typename T2,
+          typename T3,
+          typename T4,
+          typename T5,
+          typename T6,
+          typename T7,
+          typename T8,
+          typename T9,
+          typename... More>
+    requires(sizeof...(More) != 0)
+union constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, More...> {
+    using FirstNext = constexpr_union<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9>;
+    using Tail = constexpr_union<More...>;
+
+    constexpr constexpr_union(constexpr_union&&)                 = default;
+    constexpr constexpr_union(constexpr_union const&)            = default;
+    constexpr constexpr_union& operator=(constexpr_union&&)      = default;
+    constexpr constexpr_union& operator=(constexpr_union const&) = default;
+
+    constexpr constexpr_union() noexcept
+        : _first_ten() {}
+
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union() = default;
+    NEO_CONSTEXPR_DESTRUCTOR ~constexpr_union()
+        requires(not neo_is_trivially_destructible(FirstNext)
+              or not neo_is_trivially_destructible(Tail))
+    {}
+
+    template <std::size_t N>
+    using nth_type = meta::at<constexpr_union, N>;
+
+    template <std::size_t N>
+    constexpr nth_type<N>& get() & noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N>
+    constexpr nth_type<N> const& get() const& noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N>
+    constexpr nth_type<N>&& get() && noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N>
+    constexpr nth_type<N> const&& get() const&& noexcept {
+        if constexpr (N < 10) {
+            return _first_ten.template get<N>();
+        } else {
+            return _tail.template get<N - 10>();
+        }
+    }
+
+    template <std::size_t N, typename... Args>
+    constexpr nth_type<N>&
+    construct(Args&&... args) noexcept(noexcept(nth_type<N>(static_cast<Args&&...>(args)...))) {
+        if constexpr (N < 10) {
+            return _first_ten.template construct<N>(static_cast<Args&&...>(args)...);
+        } else {
+            return _tail.template construct<N - 10>(static_cast<Args&&...>(args)...);
+        }
+    }
+
+    template <std::size_t N>
+        requires requires { typename nth_type<N>; }
+    constexpr void destroy() noexcept {
+        if constexpr (N < 10) {
+            _first_ten.template destroy<N>();
+        } else {
+            _tail.template destroy<N-10>();
+        }
+    }
+
+    NEO_NO_UNIQUE_ADDRESS FirstNext _first_ten;
+    NEO_NO_UNIQUE_ADDRESS Tail _tail;
+};
+
+#endif // disabled
+
+}  // namespace neo
+
diff --git a/src/neo/constexpr_union.test.cpp b/src/neo/constexpr_union.test.cpp
new file mode 100644
index 0000000..8226268
--- /dev/null
+++ b/src/neo/constexpr_union.test.cpp
@@ -0,0 +1,68 @@
+#include <neo/constexpr_union.hpp>
+
+#include <catch2/catch.hpp>
+#include <neo/testing.hpp>
+
+#include <memory>
+
+template <std::size_t N, typename... Ts, typename... Args>
+constexpr auto make_union(Args&&... args) {
+    using onion_type = neo::constexpr_union<Ts...>;
+    onion_type onion;
+    std::construct_at(&onion.template get<N>(), args...);
+    onion.template construct<N>(args...);
+    using T  = typename onion_type::template nth_type<N>;
+    auto dup = onion.template get<N>();
+    onion.template get<N>().~T();
+    return dup;
+}
+
+TEST_CASE("Create a simple union") {
+    neo::constexpr_union<int> a;
+    a.get<0>() = 31;
+    CHECK(a.get<0>() == 31);
+
+    auto q = make_union<1, double, int, int>(31);
+    CHECK(q == 31);
+
+    constexpr auto Q = make_union<1, double, int, int>(31);
+    STATIC_REQUIRE(Q == 31);
+}
+
+TEST_CASE("Large") {
+    // clang-format off
+    constexpr auto x = make_union<31, int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int,
+                                      int, int, int, int, int, int, int, int, int>(42);
+    // clang-format on
+    STATIC_REQUIRE(x == 42);
+}
+
+struct nontrivial {
+    constexpr nontrivial() {}
+    constexpr ~nontrivial() {}
+    int value = 31;
+};
+
+TEST_CASE("Non-trivial") {
+    neo::constexpr_union<std::string, int> a;
+    a.get<1>() = 31;
+    CHECK(a.get<1>() == 31);
+    std::construct_at(&a.get<0>(), "hey");
+    CHECK(a.get<0>() == "hey");
+
+    {
+        constexpr auto n = make_union<1, int, nontrivial, std::string>();
+        STATIC_REQUIRE(n.value == 31);
+    }
+}
+
+neo::testing::cx_test_case ChangingActiveMember = [](auto) consteval {
+    neo::constexpr_union<neo::unit, neo::unit, neo::unit> onion;
+    onion.construct<1>();  // Should be constexpr-okay
+};
diff --git a/src/neo/declval.hpp b/src/neo/declval.hpp
index 36d80ee..d383d81 100644
--- a/src/neo/declval.hpp
+++ b/src/neo/declval.hpp
@@ -1,13 +1,22 @@
 #pragma once
 
+#include <neo/attrib.hpp>
+
 namespace neo {
 
+#if NEO_HAS_BUILTIN(__add_rvalue_reference)
+template <typename T>
+using add_rref_t = __add_rvalue_reference(T);
+#define _neoDeclVal(...) (((__add_rvalue_reference(__VA_ARGS__)(*)())(void*)(nullptr))())
+#else
 template <typename T>
 using add_rref_t = T&&;
+#define _neoDeclVal(...) (((::neo::add_rref_t<__VA_ARGS__>(*)())(void*)(nullptr))())
+#endif
 
 }  // namespace neo
 
 /**
  * @brief Equivalent of std::declval<T>(), but less compiler overhead
  */
-#define NEO_DECLVAL(...) (((::neo::add_rref_t<__VA_ARGS__>(*)())(void*)(nullptr))())
+#define NEO_DECLVAL(...) _neoDeclVal(__VA_ARGS__)
diff --git a/src/neo/emplacement.hpp b/src/neo/emplacement.hpp
index e95462b..85c942d 100644
--- a/src/neo/emplacement.hpp
+++ b/src/neo/emplacement.hpp
@@ -3,29 +3,24 @@
 #include "./fwd.hpp"
 
 #include <memory>
-#include <new>
 
 namespace neo {
 
 template <typename T, typename... Args>
     requires requires(void* p, Args&&... args) { ::new (p) T(NEO_FWD(args)...); }
-constexpr auto construct_at(T* addr,
-                            Args&&... args)  //
+[[deprecated("Use std::construct_at")]] constexpr auto construct_at(T* addr,
+                                                                    Args&&... args)  //
     noexcept(noexcept(::new((void*)0) T(NEO_FWD(args)...))) {
     return std::construct_at(addr, NEO_FWD(args)...);
 }
 
 template <typename T>
-constexpr void destroy_at(T* addr) {
-    addr->~T();
+[[deprecated("Use std::destroy_at")]] constexpr void destroy_at(T* addr) {
+    std::destroy_at(addr);
 }
 
-#if defined __GNUC__ || defined _MSC_VER
-// GCC, Clang, and MSVC all support constexpr placement-new, so we'll just expand a macro for it
-#define NEO_CONSTRUCT_AT(Address, ...) (::std::construct_at(Address __VA_OPT__(, ) __VA_ARGS__))
-#else
 #define NEO_CONSTRUCT_AT ::neo::construct_at
-#endif
+
 // No compiler lets this "just work"
 #define NEO_DESTROY_AT (::neo::destroy_at)
 
diff --git a/src/neo/fwd.hpp b/src/neo/fwd.hpp
index 900cc0b..526d5d6 100644
--- a/src/neo/fwd.hpp
+++ b/src/neo/fwd.hpp
@@ -1,5 +1,7 @@
 #pragma once
 
+#include <neo/attrib.hpp>
+
 namespace neo::move_detail {
 
 template <typename T>
@@ -17,8 +19,8 @@ struct strip_type<T&&> {
     using type = T;
 };
 
-#ifdef __GNUC__
-#define _neo_typeof_noref(...) __typeof__((__VA_ARGS__))
+#if NEO_HAS_BUILTIN(__remove_reference)
+#define _neo_typeof_noref(...) __remove_reference(decltype(__VA_ARGS__))
 #else
 #define _neo_typeof_noref(...) typename ::neo::move_detail::strip_type<decltype(__VA_ARGS__)>::type
 #endif
diff --git a/src/neo/get.detail.hpp b/src/neo/get.detail.hpp
new file mode 100644
index 0000000..4ace374
--- /dev/null
+++ b/src/neo/get.detail.hpp
@@ -0,0 +1,277 @@
+#pragma once
+
+#include <neo/addressof.hpp>
+#include <neo/concepts.hpp>
+#include <neo/declval.hpp>
+#include <neo/like.hpp>
+#include <neo/meta.hpp>
+
+#include <array>
+#include <cstddef>
+#include <tuple>
+#include <variant>
+
+namespace neo::_get {
+
+// Match an opt-ref like type of unspecified referred-to type
+template <typename Ref>
+concept opt_ref_like = requires(const Ref const_ref, Ref mut_ref) {
+    { const_ref ? 0 : 0 } noexcept;
+    { *const_ref };
+    { *const_ref } -> neo::weak_same_as<decltype(*mut_ref)>;
+    requires semiregular<Ref>;
+};
+
+// Match an opt-ref-like whose dereference operator returns the given type
+template <typename OptRef, typename Ref>
+concept opt_ref_to = opt_ref_like<OptRef> and requires(const OptRef ref) {
+    { *ref } -> neo::weak_same_as<Ref>;
+};
+
+// Some standard library types are not sfinae-friendly, but we want to make a SFINAE-friendly get<>
+// Use some variable templates to force the issue. In the base case, the mask is always `true`
+// since we can rely on other methods of exclusing non-stdlib types.
+template <typename Var, typename Alt>
+constexpr bool sfinae_mask = true;
+
+template <typename T, std::size_t N>
+constexpr bool sfinae_mask_n = true;
+
+template <typename... Ts, typename Alt>
+constexpr bool sfinae_mask<std::variant<Ts...>, Alt> = (weak_same_as<Ts, Alt> || ...);
+
+template <typename... Ts, typename Alt>
+constexpr bool sfinae_mask<std::tuple<Ts...>, Alt> = (weak_same_as<Ts, Alt> || ...);
+
+template <typename... Ts, std::size_t N>
+constexpr bool sfinae_mask_n<std::variant<Ts...>, N> = sizeof...(Ts) > N;
+
+template <typename... Ts, std::size_t N>
+constexpr bool sfinae_mask_n<std::tuple<Ts...>, N> = sizeof...(Ts) > N;
+
+template <typename T, std::size_t Len, std::size_t N>
+constexpr bool sfinae_mask_n<std::array<T, Len>, N> = N < Len;
+
+template <typename T, typename U, std::size_t N>
+constexpr bool sfinae_mask_n<std::pair<T, U>, N> = N < 2;
+
+template <typename Alt>
+void try_get() = delete;
+
+template <std::size_t N>
+void try_get() = delete;
+
+template <std::size_t N>
+void get() = delete;
+
+template <typename Alt>
+void get() = delete;
+
+namespace declared {
+// Does `T` have a `nth_type<>` member alias template?
+template <typename T, std::size_t N>
+concept has_member_template_nth_type = requires { typename T::template nth_type<N>; };
+// Does `T` have a valid std::tuple_element_t<N, T>?
+template <typename T, std::size_t N>
+concept has_std_tuple_element
+    = sfinae_mask_n<T, N> and requires { typename std::tuple_element_t<N, T>; };
+// Does `T` have a valid std::variant_alternative_t<N, T>?
+template <typename T, std::size_t N>
+concept has_std_variant_alternative
+    = sfinae_mask_n<T, N> and requires { typename std::variant_alternative_t<N, T>; };
+
+template <bool HasTplElem>
+struct try_var_alt {};
+
+template <bool HasTplElem>
+struct try_tpl_elem {
+    template <typename T, std::size_t N>
+    using f = try_var_alt<has_std_variant_alternative<T, N>>::template f<T, N>;
+};
+
+template <bool HasNthType>
+struct try_nth_type {
+    template <typename T, std::size_t N>
+    using f = try_tpl_elem<has_std_tuple_element<T, N>>::template f<T, N>;
+};
+
+template <>
+struct try_nth_type<true> {
+    template <typename T, std::size_t N>
+    using f = typename T::template nth_type<N>;
+};
+
+template <>
+struct try_tpl_elem<true> {
+    template <typename T, std::size_t N>
+    using f = std::tuple_element_t<N, T>;
+};
+
+template <>
+struct try_var_alt<true> {
+    template <typename T, std::size_t N>
+    using f = std::variant_alternative_t<N, T>;
+};
+
+template <typename T, std::size_t N>
+using nth = try_nth_type<has_member_template_nth_type<T, N>>::template f<T, N>;
+}  // namespace declared
+
+template <typename T, std::size_t N>
+using nth_type_t = declared::nth<remove_cvref_t<T>, N>;
+
+template <typename T, std::size_t N>
+concept has_nth_type = requires { typename nth_type_t<T, N>; };
+
+template <typename T, std::size_t N>
+using forward_nth_type_t = forward_like_tuple_t<T, nth_type_t<T, N>>;
+
+template <typename T, std::size_t N>
+concept has_member_try_get_nth = requires(T&& var) {
+    { var.template try_get<N>() } noexcept -> opt_ref_to<forward_nth_type_t<T&, N>>;
+};
+
+template <typename T, std::size_t N>
+concept has_free_try_get_nth = requires(T&& var) {
+    { try_get<N>(var) } noexcept -> opt_ref_to<forward_nth_type_t<T&, N>>;
+};
+
+template <typename T, std::size_t N>
+concept has_free_get_if_nth = requires(T&& var) {
+    requires sfinae_mask_n<remove_cvref_t<T>, N>;
+    { get_if<N>(NEO_ADDRESSOF(var)) } noexcept -> opt_ref_to<forward_nth_type_t<T&, N>>;
+};
+
+template <typename T, std::size_t N>
+concept has_any_try_get_nth_backend
+    = has_member_try_get_nth<T, N> or has_free_try_get_nth<T, N> or has_free_get_if_nth<T, N>;
+
+template <typename T, std::size_t N>
+concept has_member_get_nth = requires(T&& var) {
+    { NEO_FWD(var).template get<N>() } noexcept -> weak_same_as<forward_nth_type_t<T, N>>;
+};
+
+template <typename T, std::size_t N>
+concept has_free_get_nth = sfinae_mask_n<remove_cvref_t<T>, N> and requires(T&& var) {
+    { get<N>(NEO_FWD(var)) } noexcept -> weak_same_as<forward_nth_type_t<T, N>>;
+};
+
+template <typename T, std::size_t N>
+concept has_any_direct_get_nth_backend = not has_any_try_get_nth_backend<T, N>
+    and (has_free_get_nth<T, N> or has_member_get_nth<T, N>);
+
+constexpr inline std::size_t invalid_index = ~std::size_t(0);
+
+template <typename L, typename Alt>
+constexpr std::size_t lookup_v = invalid_index;
+
+template <neo_ttparam L, typename... Ts, typename Alt>
+    requires((weak_same_as<Ts, Alt> + ...) == 1)
+constexpr std::size_t lookup_v<L<Ts...>, Alt> = meta::find_type_v<Alt, Ts...>;
+
+template <typename T, typename Alt, std::size_t N = lookup_v<remove_cvref_t<T>, Alt>>
+concept can_try_get_alt = N != invalid_index and has_any_try_get_nth_backend<T, N>;
+
+template <typename T, typename Alt, std::size_t N = lookup_v<remove_cvref_t<T>, Alt>>
+concept can_direct_get_alt
+    = N != invalid_index and not can_try_get_alt<T, Alt> and has_any_direct_get_nth_backend<T, N>;
+
+/*
+d8b                        888
+Y8P                        888
+                           888
+888 88888b.d88b.  88888b.  888
+888 888 "888 "88b 888 "88b 888
+888 888  888  888 888  888 888
+888 888  888  888 888 d88P 888
+888 888  888  888 88888P"  888
+                  888
+                  888
+                  888
+*/
+
+template <std::size_t N>
+struct try_nth {
+    template <_get::has_any_try_get_nth_backend<N> T>
+    NEO_ALWAYS_INLINE constexpr opt_ref_like auto operator()(T&& obj) const noexcept {
+        if constexpr (has_member_try_get_nth<T, N>) {
+            return obj.template try_get<N>();
+        } else if constexpr (has_free_try_get_nth<T, N>) {
+            return try_get<N>(obj);
+        } else {
+            return get_if<N>(NEO_ADDRESSOF(obj));
+        }
+    }
+};
+
+template <std::size_t N>
+struct nth {
+    template <has_any_try_get_nth_backend<N> T>
+    NEO_ALWAYS_INLINE constexpr forward_nth_type_t<T, N> operator()(T&& obj) const {
+        auto oref = try_nth<N>{}(obj);
+        if (not oref) {
+            throw std::bad_variant_access();
+        } else {
+            return static_cast<forward_nth_type_t<T, N>>(*oref);
+        }
+    }
+
+    template <has_any_direct_get_nth_backend<N> T>
+    NEO_ALWAYS_INLINE constexpr forward_nth_type_t<T, N> operator()(T&& obj) const {
+        if constexpr (has_member_get_nth<T, N>) {
+            return NEO_FWD(obj).template get<N>();
+        } else {
+            return get<N>(NEO_FWD(obj));
+        }
+    }
+};
+
+template <typename Alt>
+struct try_as {
+    template <can_try_get_alt<Alt> T>
+    NEO_ALWAYS_INLINE constexpr opt_ref_like auto operator()(T&& obj) const noexcept {
+        constexpr auto N = lookup_v<remove_cvref_t<T>, Alt>;
+        return try_nth<N>{}(NEO_FWD(obj));
+    }
+};
+
+template <typename Alt>
+struct as {
+    template <can_try_get_alt<Alt> T>
+    NEO_ALWAYS_INLINE constexpr forward_like_tuple_t<T, Alt> operator()(T&& obj) const {
+        auto opt = try_as<Alt>{}(obj);
+        if (not opt) {
+            throw std::bad_variant_access();
+        } else {
+            return static_cast<forward_like_tuple_t<T, Alt>>(*opt);
+        }
+    }
+
+    template <can_direct_get_alt<Alt> T>
+    NEO_ALWAYS_INLINE constexpr forward_like_tuple_t<T, Alt> operator()(T&& obj) const {
+        constexpr auto N = lookup_v<remove_cvref_t<T>, Alt>;
+        return nth<N>{}(NEO_FWD(obj));
+    }
+};
+
+template <typename Alt>
+struct holds_alternative {
+    static constexpr inline try_as<Alt> try_it = {};
+
+    template <can_try_get_alt<Alt> T>
+    NEO_ALWAYS_INLINE constexpr bool operator()(const T& obj) const noexcept {
+        return static_cast<bool>(try_it(obj));
+    }
+};
+
+template <std::size_t N>
+struct holds_alternative_n {
+    static constexpr inline try_nth<N> try_it = {};
+
+    template <has_any_try_get_nth_backend<N> T>
+    NEO_ALWAYS_INLINE constexpr bool operator()(const T& obj) const noexcept {
+        return static_cast<bool>(try_it(obj));
+    }
+};
+
+}  // namespace neo::_get
diff --git a/src/neo/get.hpp b/src/neo/get.hpp
new file mode 100644
index 0000000..df73bdc
--- /dev/null
+++ b/src/neo/get.hpp
@@ -0,0 +1,88 @@
+#pragma once
+
+#include "./get.detail.hpp"
+
+#include <neo/attrib.hpp>
+#include <neo/concepts.hpp>
+#include <neo/declval.hpp>
+
+#include <cstddef>
+#include <variant>
+
+namespace neo {
+
+/**
+ * @brief Attempt to obtain the Nth alternative from a variant-like object
+ *
+ * @tparam N The index of the alternative to be requested
+ */
+template <std::size_t N>
+constexpr inline auto try_get_nth = _get::try_nth<N>{};
+
+/**
+ * @brief Obtain the Nth alternative from a variant-like or tuple-like object
+ *
+ * @tparam N The index of the alternative to be requested.
+ *
+ * If accessing a variant and the variant does not currently contain the given
+ * alternative, then bad_variant_access will be raised.
+ */
+template <std::size_t N>
+constexpr inline auto get_nth = _get::nth<N>{};
+
+/**
+ * @brief Attempt to obtain a given alternative from a variant-like object.
+ *
+ * @tparam Alt The type to attempt to obtain from the variant.
+ */
+template <typename Alt>
+constexpr inline auto try_get_as = _get::try_as<Alt>{};
+
+/**
+ * @brief Obtain a given alternative from a variant-like object.
+ *
+ * @tparam Alt The type to obtain from the variant.
+ *
+ * If the variant does not currently contain the given alternative, then bad_variant_access
+ * will be raised.
+ */
+template <typename Alt>
+constexpr inline auto get_as = _get::as<Alt>{};
+
+/**
+ * @brief The result of try_get_nth with the given type+index
+ */
+template <typename V, std::size_t N>
+using try_get_nth_t = decltype(try_get_nth<N>(NEO_DECLVAL(V)));
+
+/**
+ * @brief The result of get_nth with the given type+index
+ */
+template <typename V, std::size_t N>
+using get_nth_t = decltype(get_nth<N>(NEO_DECLVAL(V)));
+
+/**
+ * @brief The result type of try_get_as with the given type+index
+ */
+template <typename V, typename Alt>
+using try_get_as_t = decltype(try_get_as<Alt>(NEO_DECLVAL(V)));
+
+/**
+ * @brief The result type of get_as with the given type+index
+ */
+template <typename V, typename Alt>
+using get_as_t = decltype(get_as<Alt>(NEO_DECLVAL(V)));
+
+template <typename Tpl, std::size_t Index>
+concept can_get_nth = requires(Tpl&& tpl) { get_nth<Index>(NEO_FWD(tpl)); };
+
+template <typename T, typename Alternative>
+concept can_get_as = requires(T&& obj) { get_as<Alternative>(NEO_FWD(obj)); };
+
+template <typename T>
+constexpr inline auto holds_alternative = _get::holds_alternative<T>{};
+
+template <std::size_t N>
+constexpr inline auto holds_alternative_n = _get::holds_alternative_n<N>{};
+
+}  // namespace neo
diff --git a/src/neo/get.test.cpp b/src/neo/get.test.cpp
new file mode 100644
index 0000000..ba560bf
--- /dev/null
+++ b/src/neo/get.test.cpp
@@ -0,0 +1,275 @@
+#include "./get.hpp"
+
+#include <neo/testing.hpp>
+
+#include <catch2/catch.hpp>
+
+#include <array>
+#include <concepts>
+#include <tuple>
+#include <utility>
+
+static_assert(neo::_get::has_nth_type<std::variant<int>, 0>);
+static_assert(not neo::_get::has_nth_type<std::variant<int>, 1>);
+static_assert(neo::_get::has_nth_type<std::tuple<int>, 0>);
+static_assert(not neo::_get::has_nth_type<std::tuple<int>, 1>);
+static_assert(not neo::_get::has_nth_type<std::vector<int>, 0>);
+static_assert(not neo::_get::has_nth_type<std::vector<int>, 1>);
+
+static_assert(neo::_get::has_free_get_if_nth<std::variant<int>, 0>);
+static_assert(not neo::_get::has_free_get_if_nth<std::variant<int>, 1>);
+
+static_assert(std::same_as<neo::try_get_nth_t<std::variant<int>, 0>, int*>);
+static_assert(std::same_as<neo::try_get_nth_t<std::variant<int> const, 0>, int const*>);
+static_assert(std::same_as<neo::try_get_nth_t<std::variant<int> const&, 0>, int const*>);
+static_assert(std::same_as<neo::try_get_nth_t<std::variant<int>&&, 0>, int*>);
+static_assert(std::same_as<neo::get_nth_t<std::variant<int>&&, 0>, int&&>);
+static_assert(std::same_as<neo::get_nth_t<std::variant<int>&, 0>, int&>);
+static_assert(std::same_as<neo::get_nth_t<std::variant<int> const&, 0>, const int&>);
+static_assert(std::same_as<neo::get_nth_t<std::variant<int>, 0>, int&&>);
+
+static_assert(std::same_as<neo::try_get_as_t<std::variant<int>, int>, int*>);
+static_assert(std::same_as<neo::try_get_as_t<std::variant<int> const, int>, int const*>);
+static_assert(std::same_as<neo::try_get_as_t<std::variant<int> const&, int>, int const*>);
+static_assert(std::same_as<neo::try_get_as_t<std::variant<int>&&, int>, int*>);
+static_assert(std::same_as<neo::get_as_t<std::variant<int>&&, int>, int&&>);
+static_assert(std::same_as<neo::get_as_t<std::variant<int>&, int>, int&>);
+static_assert(std::same_as<neo::get_as_t<std::variant<int> const&, int>, const int&>);
+static_assert(std::same_as<neo::get_as_t<std::variant<int>, int>, int&&>);
+
+static_assert(std::same_as<neo::get_nth_t<std::tuple<int>&&, 0>, int&&>);
+static_assert(std::same_as<neo::get_nth_t<std::tuple<int>&, 0>, int&>);
+static_assert(std::same_as<neo::get_nth_t<std::tuple<int> const&, 0>, const int&>);
+static_assert(std::same_as<neo::get_nth_t<std::tuple<int>, 0>, int&&>);
+static_assert(std::same_as<neo::get_as_t<std::tuple<int>&&, int>, int&&>);
+static_assert(std::same_as<neo::get_as_t<std::tuple<int>&, int>, int&>);
+static_assert(std::same_as<neo::get_as_t<std::tuple<int> const&, int>, const int&>);
+static_assert(std::same_as<neo::get_as_t<std::tuple<int>, int>, int&&>);
+
+TEST_CASE("Get Nth from std::tuple<>") {
+    STATIC_REQUIRE(neo::can_get_nth<std::tuple<int>, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::tuple<int>&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::tuple<int> const&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::tuple<int>&&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::tuple<int> const&&, 0>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::tuple<int>, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::tuple<int>&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::tuple<int> const&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::tuple<int>&&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::tuple<int> const&&, 1>);
+
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<int>, 0>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<int&>, 0>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<int&> const&, 0>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<const int&> const&, 0>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<const int&>&, 0>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<const int&>&&, 0>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<int&&>&&, 0>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::tuple<int&&>&, 0>, int&>);
+}
+
+TEST_CASE("Can get T from a std::tuple<>") {
+    STATIC_REQUIRE(neo::can_get_as<std::tuple<int>, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::tuple<int>&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::tuple<int> const&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::tuple<int>&&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::tuple<int> const&&, int>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int>, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int>&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int> const&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int>&&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int> const&&, char>);
+
+    // The type T must be exactly an alternative, not cvr allowed:
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int>, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int>&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int> const&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int>&&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::tuple<int> const&&, int&>);
+
+    // Getting from a tuple applies the cvref qualifiers:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int>, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int>&, int>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int> const&, int>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int>&&, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int> const&&, int>, const int&&>);
+
+    // Reference collapsing:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int&>, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int&>&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int&> const&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int&>&&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::tuple<int&> const&&, int&>, int&>);
+}
+
+TEST_CASE("Get Nth from std::variant<>") {
+    STATIC_REQUIRE(neo::can_get_nth<std::variant<int>, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::variant<int>&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::variant<int> const&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::variant<int>&&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::variant<int> const&&, 0>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::variant<int>, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::variant<int>&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::variant<int> const&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::variant<int>&&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::variant<int> const&&, 1>);
+}
+
+TEST_CASE("Get T from std::variant<>") {
+    STATIC_REQUIRE(neo::can_get_as<std::variant<int>, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::variant<int>&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::variant<int> const&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::variant<int>&&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::variant<int> const&&, int>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int>, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int>&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int> const&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int>&&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int> const&&, char>);
+
+    // The type T must be exactly an alternative, no cvr allowed:
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int>, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int>&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int> const&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int>&&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::variant<int> const&&, int&>);
+
+    // Getting from a variant applies the cvref qualifiers:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::variant<int>, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::variant<int>&, int>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::variant<int> const&, int>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::variant<int>&&, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::variant<int> const&&, int>, const int&&>);
+}
+
+TEST_CASE("Get Nth from std::pair") {
+    STATIC_REQUIRE(neo::can_get_nth<std::pair<int, int>, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<std::pair<int, int>, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<std::pair<int, int>, 2>);
+
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, int>, 1>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, int&>, 1>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, int&> const&, 1>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, const int&> const&, 1>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, const int&>&, 1>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, const int&>&&, 1>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, int&&>&&, 1>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_nth_t<std::pair<int, int&&>&, 1>, int&>);
+}
+
+TEST_CASE("Can get T from a std::pair<>") {
+    STATIC_REQUIRE(neo::can_get_as<std::pair<int, char>, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::pair<int, char>&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::pair<int, char> const&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::pair<int, char>&&, int>);
+    STATIC_REQUIRE(neo::can_get_as<std::pair<int, char> const&&, int>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char>, double>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char>&, double>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char> const&, double>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char>&&, double>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char> const&&, double>);
+
+    // The type T must be exactly an alternative, no cvr allowed:
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char>, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char>&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char> const&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char>&&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<std::pair<int, char> const&&, int&>);
+
+    // Getting from a pair applies the cvref qualifiers:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int, char>, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int, char>&, int>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int, char> const&, int>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int, char>&&, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int, char> const&&, int>, const int&&>);
+
+    // Reference collapsing:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int&, char>, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int&, char>&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int&, char> const&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int&, char>&&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<std::pair<int&, char> const&&, int&>, int&>);
+}
+
+TEST_CASE("Get from std::array") {
+    using array = std::array<int, 4>;
+    STATIC_REQUIRE(neo::can_get_nth<array, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<array, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<array, 21>);
+}
+
+struct invalid_getter {
+    template <std::size_t>
+    using nth_type = int;
+
+    template <std::size_t N>
+    constexpr int const& get() & noexcept;
+    template <std::size_t N>
+    constexpr int const& get() const& noexcept;
+
+    template <std::size_t N>
+    constexpr int const& get() && noexcept;
+    template <std::size_t N>
+    constexpr int const& get() const&& noexcept;
+};
+
+struct invalid_ref_getter {
+    template <std::size_t>
+    using nth_type = int&;
+
+    // All bad: The get should always return `int&`
+    template <std::size_t N>
+    constexpr int const& get() & noexcept;
+    template <std::size_t N>
+    constexpr int const& get() const& noexcept;
+    template <std::size_t N>
+    constexpr int const& get() && noexcept;
+    template <std::size_t N>
+    constexpr int const& get() const&& noexcept;
+};
+
+struct invalid_ref_getter_v2 {
+    template <std::size_t>
+    using nth_type = int&;
+
+    // Okay: The getters return ref-to-mutable
+    template <std::size_t N>
+    constexpr int& get() & noexcept;
+    template <std::size_t N>
+    constexpr int& get() const& noexcept;
+    // Bad: We should not forward rvalue-refs
+    template <std::size_t N>
+    constexpr int&& get() && noexcept;
+    template <std::size_t N>
+    constexpr int&& get() const&& noexcept;
+};
+
+TEST_CASE("Reject not-tuple-like types") {
+    // Bad: The non-const getter returns a ref-to-const but the declared type is not `const&`
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<invalid_getter&, 0>);
+    // Okay: The const `get` overload does the correct thing
+    STATIC_REQUIRE(neo::can_get_nth<const invalid_getter&, 0>);
+
+    // Bad: The rvalue-getter returns an lvalue reference
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<invalid_getter&&, 0>);
+    // Bad: The const&& `get` overload does nto return an value-ref-to-const
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<const invalid_getter&&, 0>);
+
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<invalid_ref_getter&, 0>);
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<const invalid_ref_getter&, 0>);
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<invalid_ref_getter&&, 0>);
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<const invalid_ref_getter&&, 0>);
+
+    STATIC_REQUIRE(neo::can_get_nth<invalid_ref_getter_v2&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<const invalid_ref_getter_v2&, 0>);
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<invalid_ref_getter_v2&&, 0>);
+    STATIC_REQUIRE_FALSE(neo::can_get_nth<const invalid_ref_getter_v2&&, 0>);
+}
+
+neo::testing::cx_test_case TestHoldsAlternative = [](auto check) consteval {
+    std::variant<int, double> var;
+    check(neo::holds_alternative<int>(var));
+    check(not neo::holds_alternative<double>(var));
+    check(neo::holds_alternative_n<0>(var));
+    check(not neo::holds_alternative_n<1>(var));
+};
diff --git a/src/neo/invoke.hpp b/src/neo/invoke.hpp
index c01f47e..5d45b9d 100644
--- a/src/neo/invoke.hpp
+++ b/src/neo/invoke.hpp
@@ -16,9 +16,9 @@ namespace neo {
  */
 template <typename Fn, typename... Args>
 concept simple_invocable = requires(Fn&& fn, Args&&... args) {
-                               NEO_FWD(fn)
-                               (NEO_FWD(args)...);
-                           };
+    NEO_FWD(fn)
+    (NEO_FWD(args)...);
+};
 
 namespace invoke_detail {
 
@@ -45,7 +45,7 @@ struct memfun_invoker {
     DECL_MEMFUN_INV(const&);
     DECL_MEMFUN_INV(volatile&);
     DECL_MEMFUN_INV(const volatile&);
-    DECL_MEMFUN_INV(&noexcept);
+    DECL_MEMFUN_INV(& noexcept);
     DECL_MEMFUN_INV(const& noexcept);
     DECL_MEMFUN_INV(volatile& noexcept);
     DECL_MEMFUN_INV(const volatile& noexcept);
@@ -54,7 +54,7 @@ struct memfun_invoker {
     DECL_MEMFUN_INV(const&&);
     DECL_MEMFUN_INV(volatile&&);
     DECL_MEMFUN_INV(const volatile&&);
-    DECL_MEMFUN_INV(&&noexcept);
+    DECL_MEMFUN_INV(&& noexcept);
     DECL_MEMFUN_INV(const&& noexcept);
     DECL_MEMFUN_INV(volatile&& noexcept);
     DECL_MEMFUN_INV(const volatile&& noexcept);
@@ -74,11 +74,29 @@ struct call_invoker {
         NEO_RETURNS(NEO_FWD(fn)(NEO_FWD(args)...));
 };
 
+template <bool IsMemberPointer>
+struct pick_invoker_1;
+
+template <>
+struct pick_invoker_1<false> {
+    // Invocable is not a member pointer, so defer to the regular calling semantics
+    template <typename>
+    using f = call_invoker;
+};
+
+template <>
+struct pick_invoker_1<true> {
+    // Invocable is a pointer-to-member.
+    template <typename Ptr>
+    using f = conditional_t<member_function_pointer<Ptr>,
+                            // Invoke as a member function
+                            memfun_invoker,
+                            // "Invoke" as member object
+                            memobj_invoker>;
+};
+
 template <typename Fn, typename D = remove_cvref_t<Fn>>
-using pick_invoker_t = conditional_t<
-    not neo_is_member_pointer(D),
-    call_invoker,
-    conditional_t<neo_is_member_function_pointer(D), memfun_invoker, memobj_invoker>>;
+using pick_invoker_t = pick_invoker_1<member_pointer<D>>::template f<D>;
 
 }  // namespace invoke_detail
 
@@ -96,10 +114,9 @@ struct invoke_fn {
 /**
  * @brief "Invoke" an invocable object. Like std::invoke, but cleaner and less debug overhead
  *
- * @tparam Func The invocable. Must be a function, or object that has an operator() overload
+ * @tparam Func The invocable. Must be a function, or object that has an operator() overload, or a
+ * pointer-to-member.
  * @tparam Args The arguments to pass to the invocable.
- *
- * This is the base overload that will catch things that are callable, including with operator()
  */
 inline constexpr invoke_fn invoke{};
 
diff --git a/src/neo/like.hpp b/src/neo/like.hpp
index 882a2a3..fb886fe 100644
--- a/src/neo/like.hpp
+++ b/src/neo/like.hpp
@@ -1,96 +1,107 @@
 #pragma once
 
-#include <type_traits>
+#include "./attrib.hpp"
+#include "./type_traits.hpp"
 
 namespace neo {
 
 namespace like_detail {
 
-template <bool B>
-struct conditional {
-    template <typename T, typename F>
-    using eval = F;
-};
+template <bool IsConst, int Nref>
+struct forward_like_impl;
 
 template <>
-struct conditional<true> {
-    template <typename T, typename F>
-    using eval = T;
-};
+struct forward_like_impl<true, 1> {
+    template <typename T>
+    using merge = add_lvalue_reference_t<add_const_t<remove_reference_t<T>>>;
 
-template <typename T, typename U>
-concept similar = std::is_same_v<std::remove_cvref_t<T>, std::remove_cvref_t<U>>;
+    template <typename T>
+    using tuple = add_lvalue_reference_t<add_const_t<T>>;
 
-template <typename From, typename Onto>
-struct copy_ref {
-    using type = Onto;
+    template <typename T>
+    using language = add_lvalue_reference_t<add_const_t<T>>;
 };
 
-template <typename From, typename Onto>
-struct copy_ref<From&&, Onto> {
-    using type = Onto&&;
-};
+template <>
+struct forward_like_impl<true, 0> {
+    template <typename T>
+    using merge = add_rvalue_reference_t<add_const_t<remove_reference_t<T>>>;
+
+    template <typename T>
+    using tuple = add_rvalue_reference_t<add_const_t<T>>;
 
-template <typename From, typename Onto>
-struct copy_ref<From&, Onto> {
-    using type = Onto&;
+    template <typename T>
+    using language = add_lvalue_reference_t<add_const_t<T>>;
 };
 
-template <typename From, typename Onto>
-using copy_ref_t = typename copy_ref<From, Onto>::type;
+template <>
+struct forward_like_impl<false, 1> {
+    template <typename T>
+    using merge = add_lvalue_reference_t<remove_reference_t<T>>;
+
+    template <typename T>
+    using tuple = add_lvalue_reference_t<T>;
 
-template <bool IsRValRef>
-struct override_ref {
     template <typename T>
-    using eval = T&;
+    using language = add_lvalue_reference_t<T>;
 };
 
 template <>
-struct override_ref<true> {
+struct forward_like_impl<false, 0> {
     template <typename T>
-    using eval = std::remove_reference_t<T>&&;
-};
+    using merge = add_rvalue_reference_t<remove_reference_t<T>>;
 
-template <typename From, typename Onto>
-using override_ref_t = typename override_ref<std::is_rvalue_reference_v<From>>::template eval<Onto>;
+    template <typename T>
+    using tuple = add_rvalue_reference_t<T>;
 
-template <bool IsConst>
-struct copy_const;
+    template <typename T>
+    using language = add_lvalue_reference_t<T>;
+};
 
 template <>
-struct copy_const<true> {
+struct forward_like_impl<false, 2> : forward_like_impl<false, 0> {
     template <typename T>
-    using eval = copy_ref_t<T, std::remove_reference_t<T> const>;
+    using language = add_lvalue_reference_t<T>;
 };
 
 template <>
-struct copy_const<false> {
+struct forward_like_impl<true, 2> : forward_like_impl<true, 0> {
     template <typename T>
-    using eval = T;
+    using language = add_lvalue_reference_t<add_const_t<T>>;
 };
 
-template <typename From, typename To>
-using copy_const_t =
-    typename copy_const<std::is_const_v<std::remove_reference_t<From>>>::template eval<To>;
-
-template <typename From, typename To>
-using copy_cvref_t = copy_ref_t<From&&, copy_const_t<From, To>>;
+template <typename T>
+using model = forward_like_impl<const_type<remove_reference_t<T>>,
+                                rvalue_reference_type<T>       ? 2
+                                    : lvalue_reference_type<T> ? 1
+                                                               : 0>;
 
 }  // namespace like_detail
 
 /**
  * @brief Merge the cvref-qualifiers of `T` onto `U`
- *
- * @tparam T
- * @tparam U
  */
 template <typename T, typename U>
-using forward_like_t
-    = like_detail::override_ref_t<T&&, like_detail::copy_const_t<T, std::remove_reference_t<U>>>;
+using forward_like_t = like_detail::model<T>::template merge<U>;
 
-template <typename T>
-constexpr decltype(auto) forward_like(auto&& arg) noexcept {
-    return static_cast<forward_like_t<T, decltype(arg)>>(arg);
+/**
+ * @brief Use a forward-like as if we were calling get<>() with a tuple.
+ *
+ * @tparam Owner The "owner" of the object.
+ * @tparam T the type to be transformed.
+ *
+ * - If `T` is a non-reference type, the cvref qualifiers from `Owner` will be applied
+ *   to `T`.
+ * - Otherwise, the cv-qualifiers from `Owner` are ignored, and the reference qualifiers
+ *   of `Owner` are concatenated with the reference qualifiers of `T` and the resulting
+ *   collapsed reference type is the final result.
+ */
+template <typename Owner, typename T>
+using forward_like_tuple_t = like_detail::model<Owner>::template tuple<T>;
+
+template <typename T, typename U>
+NEO_ALWAYS_INLINE constexpr forward_like_t<T, U> forward_like(U&& arg) noexcept {
+    return static_cast<forward_like_t<T, U>>(arg);
 }
 
 }  // namespace neo
diff --git a/src/neo/meta.hpp b/src/neo/meta.hpp
index b4f552a..6171d99 100644
--- a/src/neo/meta.hpp
+++ b/src/neo/meta.hpp
@@ -1,5 +1,8 @@
 #pragma once
 
+#include <neo/attrib.hpp>
+#include <neo/type_traits.hpp>
+
 #include <utility>
 
 #define u64 unsigned long long
@@ -380,12 +383,74 @@ struct remove_prefix_ {
     struct from;
 
     template <neo_ttparam L, tn... Ts>
+        requires((sizeof...(Ts) >= N))
     struct from<L<Ts...>> {
-        static_assert(sizeof...(Ts) >= N, "remove_prefix N is too large");
         using type = decltype(remove_prefix_fn<L, voids>::r(static_cast<tag<Ts>*>(nullptr)...));
     };
 };
 
+template <>
+struct remove_prefix_<0> {
+    template <tn L>
+    struct from {
+        using type = L;
+    };
+};
+
+template <>
+struct remove_prefix_<1> {
+    template <tn L>
+    struct from;
+
+    template <neo_ttparam L>
+    struct fn {
+        template <typename... Tail>
+        static L<Tail...> r(void*, tag<Tail>*...);
+    };
+
+    template <neo_ttparam L, tn... Ts>
+        requires((sizeof...(Ts) >= 1))
+    struct from<L<Ts...>> {
+        using type = decltype(fn<L>::r(static_cast<tag<Ts>*>(nullptr)...));
+    };
+};
+
+template <>
+struct remove_prefix_<2> {
+    template <tn L>
+    struct from;
+
+    template <neo_ttparam L>
+    struct fn {
+        template <typename... Tail>
+        static L<Tail...> r(void*, void*, tag<Tail>*...);
+    };
+
+    template <neo_ttparam L, tn... Ts>
+        requires((sizeof...(Ts) >= 1))
+    struct from<L<Ts...>> {
+        using type = decltype(fn<L>::r(static_cast<tag<Ts>*>(nullptr)...));
+    };
+};
+
+template <>
+struct remove_prefix_<3> {
+    template <tn L>
+    struct from;
+
+    template <neo_ttparam L>
+    struct fn {
+        template <typename... Tail>
+        static L<Tail...> r(void*, void*, void*, tag<Tail>*...);
+    };
+
+    template <neo_ttparam L, tn... Ts>
+        requires((sizeof...(Ts) >= 1))
+    struct from<L<Ts...>> {
+        using type = decltype(fn<L>::r(static_cast<tag<Ts>*>(nullptr)...));
+    };
+};
+
 }  // namespace detail
 
 namespace tacit {
@@ -404,11 +469,44 @@ struct remove_prefix {
 template <tn L, u64 N>
 using remove_prefix = tn detail::remove_prefix_<N>::tl from<L>::type;
 
+namespace detail {
+
+#if NEO_HAS_BUILTIN(__type_pack_element)
+template <typename Seq>
+struct intrin_at_impl;
+
+template <neo_ttparam L, typename... Ts>
+struct intrin_at_impl<L<Ts...>> {
+    template <u64 N>
+    using f = __type_pack_element<N, Ts...>;
+};
+#endif
+
+}  // namespace detail
+
+#if NEO_HAS_BUILTIN(__type_pack_element)
+/**
+ * @brief Select the `Nth` element of the given type-list.
+ *
+ * @tparam L A list of types to choose from
+ * @tparam N The zero-based index of the type to be selected.
+ */
+template <tn L, u64 N>
+using at = detail::intrin_at_impl<L>::template f<N>;
 /**
- * @brief Obtain the Nth element of the given typelist
+ * @brief Obtain the `Nth` type from the given list of types (zero-based indexing)
+ *
+ * @tparam N The zero-based index of the type to select
+ * @tparam Ts A list of types to choose from
  */
+template <u64 N, typename... Ts>
+using pack_at = __type_pack_element<N, Ts...>;
+#else
 template <tn L, u64 N>
 using at = head<remove_prefix<L, N>>;
+template <u64 N, typename... Ts>
+using pack_at = at<list<Ts...>, N>;
+#endif
 
 namespace tacit {
 
@@ -561,6 +659,51 @@ struct rebind {
 template <typename L, neo_ttparam NewL>
 using rebind = typename tacit::rebind<NewL>::tl f<L>;
 
+namespace find_type_detail {
+
+template <u64 N, bool Same>
+struct find_type_one {};
+
+template <u64 N>
+struct find_type_one<N, true> {
+    enum { value = N };
+};
+
+template <bool B>
+struct find_base {
+    template <u64 N>
+    struct base {};
+};
+
+template <>
+struct find_base<true> {
+    template <u64 N>
+    struct base {
+        enum { value = N };
+    };
+};
+
+template <typename T, typename List, typename Seq = std::make_index_sequence<meta::len_v<List>>>
+struct finder;
+
+template <std::size_t... Ns, typename T, neo_ttparam L, typename... Ts>
+struct finder<T, L<Ts...>, std::index_sequence<Ns...>>
+    : find_base<neo::weak_same_as<T, Ts>>::template base<Ns>... {};
+
+}  // namespace find_type_detail
+
+template <typename Needle, typename... Ts>
+    requires((weak_same_as<Needle, Ts> or ...))
+constexpr std::size_t find_type_v
+    = find_type_detail::finder<Needle, meta::list<Ts...>, std::index_sequence_for<Ts...>>::value;
+
+template <typename Needle, typename L>
+    requires requires { find_type_detail::finder<Needle, L>::value; }
+constexpr std::size_t find_type_in = find_type_detail::finder<Needle, L>::value;
+
+template <typename Needle, typename... Ts>
+struct find_type : meta::val<find_type_v<Needle, Ts...>> {};
+
 }  // namespace neo::meta
 
 #undef u64
diff --git a/src/neo/object_box.hpp b/src/neo/object_box.hpp
index 5486907..494a7e6 100644
--- a/src/neo/object_box.hpp
+++ b/src/neo/object_box.hpp
@@ -1,123 +1,298 @@
 #pragma once
 
-#pragma once
-
 #include "./addressof.hpp"
 #include "./attrib.hpp"
 #include "./concepts.hpp"
 #include "./fwd.hpp"
 #include "./like.hpp"
+#include "./type_traits.hpp"
 
-#include <concepts>
+#include <compare>
+#include <type_traits>
 #include <utility>
 
 namespace neo {
 
-namespace _obox_detail {
-
-template <typename T>
-struct box_base {
-    /// The exact type that was given for the object_box
-    using boxed_type = T;
-
-    /// Whether the box contains a scalar type
-    static constexpr inline bool contains_scalar = scalar_type<T>;
-    /// Whether the box contains an object type
-    static constexpr inline bool contains_object = object_type<T>;
-    /// Whether the box wraps a reference
-    static constexpr inline bool contains_ref = reference_type<T>;
-    /// Whether the box wraps a void type
-    static constexpr inline bool contains_void = void_type<T>;
-};
-
-}  // namespace _obox_detail
-
 /**
  * @brief Defines a object type that contains a (possibly non-object) type.
  *
  * @tparam T Any scalar type, object type, reference type, void type, bounded array type,
- * or any cv-qualified type thereof.
+ * or any cv-qualified type thereof. Unbounded arrays are not supported.
  *
  * For object types, inherits the construct/assign requirements of the wrapped
  * type.
  *
  * For references, is trivially copyable, but not default-constructible.
  *
- * For void, is empty and semiregular.
+ * Defines operator== and operator<=> for applicable types. For references, the
+ * operators are defined on the equivalent pointer values. For void, all instances
+ * are equal.
+ *
+ * For `void`, is empty and regular.
  */
 template <typename T>
 class object_box;
 
-template <object_type T>
-class object_box<T> : public _obox_detail::box_base<T> {
-    // The contained object
+namespace detail {
+
+// Put the ADL-visible specail functions() in a base class for object box, otherwise object_box
+// would generate new function templates for every specialization, which can get
+// expensive. This is only used for the plain object_type specialization
+struct object_box_operators {
+    template <typename T>
+    constexpr friend void swap(object_box<T>& left,
+                               object_box<T>& right)  //
+        noexcept(noexcept(neo::swap(left.get(), right.get()))) {
+        neo::swap(left.get(), right.get());
+    }
+
+    bool operator==(const object_box_operators&) const  = default;
+    auto operator<=>(const object_box_operators&) const = default;
+};
+
+}  // namespace detail
+
+/**
+ * Implementation of object_box for non-array object types
+ */
+template <typename T>
+    requires object_type<T> and (not array_type<T>)
+class object_box<T> : detail::object_box_operators {
     NEO_NO_UNIQUE_ADDRESS T _value;
 
+public:
+    object_box() = default;
+
+    // Defer to the default operators
+    bool operator==(const object_box&) const  = default;
+    auto operator<=>(const object_box&) const = default;
+
+    /**
+     * @brief Construct from any type that is explicitly-convertible-to the underlying type.
+     *
+     * This constructor is explicit if the underlying conversion is never implicit
+     */
+    template <unalike<object_box> U>
+        requires explicit_convertible_to<U&&, T>
+    // We are explicit if the implicit conversion is not viable
+    explicit(not implicit_convertible_to<U&&, T>) constexpr object_box(U&& arg) noexcept(
+        noexcept(T(NEO_FWD(arg))))
+        : _value(NEO_FWD(arg)) {}
+
+    /**
+     * @brief In-place constructor. Calls the underlying constructor directly.
+     */
+    template <typename... Args>
+        requires constructible_from<T, Args...>
+    constexpr explicit object_box(std::in_place_t,
+                                  Args&&... args)  //
+        noexcept(noexcept(T(NEO_FWD(args)...)))
+        : _value(NEO_FWD(args)...) {}
+
+    /// Obtain a reference to the boxed value.
+    [[nodiscard]] constexpr T&        get() & noexcept { return _value; }
+    [[nodiscard]] constexpr const T&  get() const& noexcept { return _value; }
+    [[nodiscard]] constexpr T&&       get() && noexcept { return NEO_MOVE(_value); }
+    [[nodiscard]] constexpr const T&& get() const&& noexcept { return NEO_MOVE(_value); }
+
+    /**
+     * @brief Obtain the boxed value as-if by forwarding reference.
+     */
+    [[nodiscard]] constexpr T&&       forward() noexcept { return NEO_MOVE(_value); }
+    [[nodiscard]] constexpr const T&& forward() const noexcept { return NEO_MOVE(_value); }
+
+    constexpr void friend do_repr(auto out, const object_box* self) noexcept {
+        out.type("[boxed {}]", out.template repr_type<T>("?"));
+        if (self) {
+            out.value("{}", out.repr_value(self->get(), "?"));
+        }
+    }
+};
+
+// Implementation of object_box for array types
+template <typename Element, std::size_t Length>
+class object_box<Element[Length]> {
+    using array_type = Element[Length];
+
+    // The contained object
+    NEO_NO_UNIQUE_ADDRESS array_type _array;
+
     // Tag to construct from an array
     struct _array_construct {};
 
     // In-place construct an array member from a given array
     template <typename Arr, std::size_t... Idx>
     constexpr object_box(_array_construct, Arr&& arr, std::index_sequence<Idx...>) noexcept
-        : _value{neo::forward_like<Arr>(arr[Idx])...} {}
+        : _array{neo::forward_like<Arr>(arr[Idx])...} {}
 
 public:
     object_box() = default;
 
-    // clang-format off
-    template <unalike<object_box> U>
-        requires explicit_convertible_to<U&&, T>
-        explicit(not implicit_convertible_to<U&&, T>)
-    constexpr object_box(U&& arg)
-        noexcept(noexcept(T(NEO_FWD(arg))))
-        : _value(NEO_FWD(arg)) {}
+    /**
+     * @brief In-place constructor for constructing array elements.
+     *
+     * @param args The values for the array elements. Each element is constructed in-place via
+     * conversion It is required that `args` be the same number of arguments as array elements.
+     */
+    template <convertible_to<Element>... Args>
+        requires(sizeof...(Args) <= Length)
+    constexpr explicit object_box(std::in_place_t, Args&&... args)
+        // We are noexcept if each element conversion is noexcept
+        noexcept((noexcept(static_cast<Element>(NEO_FWD(args))) and ...))
+        : _array{NEO_FWD(args)...} {}
+
+    /**
+     * @brief Array-move-constructor. If the underlying type is an array, construct
+     * from an array of values of a type that is convertible to element type of
+     * the wrapped array.
+     *
+     * @tparam Elem An element type from which to construct. Must be convertible
+     * to the underlying array's element type.
+     * @tparam Len The deduced length of the array argument.
+     */
+    template <typename FromElement, std::size_t OtherLen>
+        requires convertible_to<FromElement, Element>
+    constexpr explicit object_box(FromElement (&&arr)[OtherLen]) noexcept(
+        noexcept(static_cast<Element>(NEO_DECLVAL(FromElement&&))))
+        : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence<OtherLen>{}) {}
+
+    /**
+     * @brief Array-copy-constructor. If the underlying type is an array, construct
+     * from an array of values of a type that is convertible to element type of
+     * the wrapped array.
+     *
+     * @tparam Elem An element type from which to construct. Must be convertible
+     * to the underlying array's element type.
+     * @tparam Len The deduced length of the array argument.
+     */
+    template <typename FromElement, std::size_t OtherLength>
+        requires convertible_to<FromElement, Element>
+    constexpr explicit object_box(FromElement const (&arr)[OtherLength]) noexcept(
+        noexcept(static_cast<Element>(NEO_DECLVAL(const FromElement&))))
+        : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence<OtherLength>{}) {}
 
-    template <typename Elem, std::size_t Len>
-    requires array_type<T>
-         and convertible_to<Elem, remove_all_extents_t<T>>
-    constexpr object_box(Elem (&&arr)[Len]) noexcept
+    // in-place constructor for moving arrays
+    template <typename FromElement, std::size_t Len>
+        requires convertible_to<FromElement, Element>
+    constexpr explicit object_box(std::in_place_t, FromElement (&&arr)[Len]) noexcept(
+        noexcept(static_cast<Element>(NEO_DECLVAL(FromElement&&))))
         : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence<Len>{}) {}
 
-    template <typename Elem, std::size_t Len>
-    requires array_type<T>
-         and convertible_to<Elem, remove_all_extents_t<T>>
-    constexpr object_box(Elem (&arr)[Len]) noexcept
+    // in-place constructor for copying arrays
+    template <typename FromElement, std::size_t Len>
+        requires convertible_to<FromElement, Element>
+    constexpr explicit object_box(std::in_place_t, const FromElement (&arr)[Len]) noexcept(
+        noexcept(static_cast<Element>(NEO_DECLVAL(const FromElement&))))
         : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence<Len>{}) {}
 
     /// Obtain a reference to the boxed value.
-    [[nodiscard]] constexpr T&        get() & noexcept { return _value; }
-    [[nodiscard]] constexpr const T&  get() const& noexcept { return _value; }
-    [[nodiscard]] constexpr T&&       get() && noexcept { return NEO_MOVE(_value); }
-    [[nodiscard]] constexpr const T&& get() const&& noexcept { return NEO_MOVE(_value); }
+    [[nodiscard]] constexpr array_type&        get() & noexcept { return _array; }
+    [[nodiscard]] constexpr const array_type&  get() const& noexcept { return _array; }
+    [[nodiscard]] constexpr array_type&&       get() && noexcept { return NEO_MOVE(_array); }
+    [[nodiscard]] constexpr const array_type&& get() const&& noexcept { return NEO_MOVE(_array); }
 
-    constexpr T*       operator->() noexcept { return neo::addressof(_value); }
-    constexpr const T* operator->() const noexcept { return neo::addressof(_value); }
+    /**
+     * @brief Obtain the boxed value as-if by forwarding reference.
+     */
+    [[nodiscard]] constexpr array_type&&       forward() noexcept { return NEO_MOVE(_array); }
+    [[nodiscard]] constexpr const array_type&& forward() const noexcept { return NEO_MOVE(_array); }
 
     constexpr void friend do_repr(auto out, const object_box* self) noexcept {
-        out.type("[boxed {}]", out.template repr_type<T>("?"));
+        out.type("[boxed {}]", out.template repr_type<array_type>("?"));
         if (self) {
             out.value("{}", out.repr_value(self->get(), "?"));
         }
     }
+
+    // operator== used for arrays of equality-comparable values
+    constexpr bool operator==(const object_box& other) const noexcept
+        requires equality_comparable<remove_all_extents_t<array_type>>
+    {
+        return _equal(this->_array, other._array);
+    }
+
+    // operator<=> used for arrays of totally ordered values
+    constexpr auto operator<=>(const object_box& other) const noexcept
+        requires totally_ordered<remove_all_extents_t<array_type>>
+    {
+        using Cat = std::common_comparison_category_t<
+            std::compare_three_way_result_t<std::remove_all_extents_t<array_type>>>;
+        return _compare<Cat>(this->_array, other._array);
+    }
+
+private:
+    template <typename E>
+    constexpr bool _equal(const E& left, const E& right) const noexcept {
+        if constexpr (not neo::array_type<E>) {
+            const bool eq = left == right;
+            return eq;
+        } else {
+            // Compare the two arrays element-by-element
+            auto       iter       = left + 0;
+            auto       other_iter = right + 0;
+            const auto stop       = iter + std::extent_v<E>;
+            for (; iter != stop; ++iter, ++other_iter) {
+                if (not _equal(*iter, *other_iter)) {
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+
+    template <typename Cat, typename E>
+    constexpr Cat _compare(const E& left, const E& right) const noexcept {
+        if constexpr (not neo::array_type<E>) {
+            Cat c = std::compare_strong_order_fallback(left, right);
+            return c;
+        } else {
+            auto       l_iter = left + 0;
+            auto       r_iter = right + 0;
+            const auto stop   = l_iter + std::extent_v<E>;
+            Cat        r      = std::strong_ordering::equal;
+            for (; l_iter != stop and r == 0; ++l_iter, ++r_iter) {
+                r = _compare<Cat>(*l_iter, *r_iter);
+            }
+            return r;
+        }
+    }
 };
 
+/**
+ * @brief Implementation for reference types.
+ *
+ * Assigning to an object_box from another object box will rebind the reference.
+ * @tparam Ref
+ */
 template <reference_type Ref>
-class object_box<Ref> : public _obox_detail::box_base<Ref> {
+class object_box<Ref> {
     using Pointer = add_pointer_t<Ref>;
     Pointer _ptr;
 
 public:
+    // boxed references are not default-constructible
     constexpr object_box() = delete;
 
+    // Construct a boxed reference from a compatible referred-to type.
     template <typename U>
-    explicit constexpr object_box(U&& arg) noexcept requires requires(void (*fn)(Pointer)) {
-        fn(neo::addressof(arg));
-    } : _ptr(neo::addressof(arg)) {
-    }
+    // Require that we can pointer-convert to the stored type. Checking
+    // for reference conversion would be unsafe since it could invoke an implicit conversion
+    // constructor for materializing a temporary
+        requires convertible_to<add_pointer_t<U>, Pointer>
+    explicit constexpr object_box(U&& arg) noexcept
+        : _ptr(neo::addressof(arg)) {}
+
+    template <typename U>
+        requires convertible_to<add_pointer_t<U>, Pointer>
+    explicit constexpr object_box(std::in_place_t, U&& arg) noexcept
+        : _ptr(NEO_ADDRESSOF(arg)) {}
 
     /// Obtain the boxed reference
     [[nodiscard]] constexpr Ref& get() const noexcept { return *_ptr; }
 
+    /// Obtain the boxed reference.
+    [[nodiscard]] constexpr Ref& forward() const noexcept { return *_ptr; }
+
     constexpr Pointer operator->() const noexcept { return _ptr; }
 
     constexpr void friend do_repr(auto out, const object_box* self) noexcept {
@@ -126,12 +301,26 @@ class object_box<Ref> : public _obox_detail::box_base<Ref> {
             out.value("{}", out.repr_value(self->get(), "?"));
         }
     }
+
+    bool operator==(const object_box& other) const  = default;
+    auto operator<=>(const object_box& other) const = default;
 };
 
+/**
+ * @brief Implementation of object_box for void types.
+ *
+ * This object_box is default-constructible and empty
+ */
 template <void_type Void>
-class object_box<Void> : public _obox_detail::box_base<Void> {
+class object_box<Void> {
 public:
+    object_box() = default;
+    constexpr explicit object_box(std::in_place_t) noexcept {}
+
+    // Returns void for boxed void
     constexpr remove_cv_t<Void> get() const noexcept {}
+    // Returns void for boxed void
+    constexpr remove_cv_t<Void> forward() const noexcept {}
 
     constexpr void friend do_repr(auto out, const object_box* self) noexcept {
         out.type("[boxed {}]", out.template repr_type<Void>());
@@ -139,8 +328,18 @@ class object_box<Void> : public _obox_detail::box_base<Void> {
             out.value("(void)");
         }
     }
+
+    constexpr bool operator==(const object_box&) const noexcept  = default;
+    constexpr auto operator<=>(const object_box&) const noexcept = default;
 };
 
+/**
+ * @brief The sole argument deduction guide for object_box is designed to support
+ * perfect forwarding of objects. If given an lvalue reference, the deduced box
+ * is a boxed reference. If given an rvalue, deduces to a box of the value's type.
+ *
+ * This will never deduce `void`
+ */
 template <typename T>
 object_box(T&& arg) -> object_box<T>;
 
diff --git a/src/neo/object_box.test.cpp b/src/neo/object_box.test.cpp
index 56e23a0..c5c16ca 100644
--- a/src/neo/object_box.test.cpp
+++ b/src/neo/object_box.test.cpp
@@ -76,4 +76,61 @@ TEST_CASE("Array box") {
     CHECK(box2.get()[0] == 1);
     CHECK(box2.get()[1] == 2);
     CHECK(box2.get()[2] == 3);
+
+    neo::object_box box3{std::as_const(arr)};
+    static_assert(std::same_as<decltype(box3), neo::object_box<int const(&)[3]>>);
+    CHECK(box3.get()[0] == 1);
+    CHECK(box3.get()[1] == 2);
+    CHECK(box3.get()[2] == 3);
+
+    neo::object_box<int[3]> box_copy_const{std::as_const(carr)};
+    static_assert(std::same_as<decltype(box_copy_const), neo::object_box<int[3]>>);
+    CHECK(box_copy_const.get()[0] == 1);
+    CHECK(box_copy_const.get()[1] == 2);
+    CHECK(box_copy_const.get()[2] == 3);
+
+    neo::object_box<int[3]> box_copy_rval{NEO_MOVE(carr)};
+    static_assert(std::same_as<decltype(box_copy_rval), neo::object_box<int[3]>>);
+    CHECK(box_copy_rval.get()[0] == 1);
+    CHECK(box_copy_rval.get()[1] == 2);
+    CHECK(box_copy_rval.get()[2] == 3);
+
+    neo::object_box<int[3]> box_in_place_construct{std::in_place, carr};
+    CHECK(box_in_place_construct.get()[0] == 1);
+    CHECK(box_in_place_construct.get()[1] == 2);
+    CHECK(box_in_place_construct.get()[2] == 3);
 }
+
+TEST_CASE("Emplacement construct") {
+    neo::object_box<int> i{std::in_place, 21};
+    CHECK(i.get() == 21);
+}
+
+TEST_CASE("Equality+Ordering") {
+    SECTION("regular") {
+        constexpr neo::object_box<int> a{31};
+        CHECK(a == a);
+        CHECK_FALSE(a < a);
+    }
+    SECTION("Arrays") {
+        constexpr neo::object_box<int[3]> a{std::in_place, 1, 3, 4};
+        STATIC_REQUIRE(a == a);
+        STATIC_REQUIRE_FALSE(a < a);
+        constexpr neo::object_box<int[3]> b{std::in_place, 3, 1, 9};
+        STATIC_REQUIRE_FALSE(a == b);
+        STATIC_REQUIRE(a < b);
+    }
+    SECTION("void") {
+        constexpr neo::object_box<void> a;
+        CHECK(a == a);
+        CHECK_FALSE(a < a);
+    }
+}
+
+static_assert(neo::regular<neo::object_box<int>>);
+static_assert(neo::regular<neo::object_box<int[12]>>);
+static_assert(neo::totally_ordered<neo::object_box<int>>);
+static_assert(neo::totally_ordered<neo::object_box<int[12]>>);
+static_assert(neo::totally_ordered<neo::object_box<int&>>);
+static_assert(neo::totally_ordered<neo::object_box<void>>);
+static_assert(neo::regular<neo::object_box<void>>);
diff --git a/src/neo/object_t.hpp b/src/neo/object_t.hpp
new file mode 100644
index 0000000..30cd62e
--- /dev/null
+++ b/src/neo/object_t.hpp
@@ -0,0 +1,45 @@
+#pragma once
+
+#include <neo/ref.hpp>
+#include <neo/type_traits.hpp>
+#include <neo/unit.hpp>
+
+namespace neo {
+
+namespace detail {
+
+template <bool IsObject, bool IsArray, bool IsReference, bool IsVoid>
+struct object_impl;
+
+template <>
+struct object_impl<true, false, false, false> {
+    template <typename T>
+    using f = T;
+};
+
+template <>
+struct object_impl<false, false, true, false> {
+    template <typename T>
+    using f = reference_object<T>;
+};
+
+template <>
+struct object_impl<false, false, false, true> {
+    template <typename>
+    using f = unit;
+};
+
+}  // namespace detail
+
+/**
+ * @brief Extra-light alternative to object_box
+ *
+ * If `T` is an object type, yields `T`. If `T` is `void`, yields `neo::unit`. If `T` is a
+ * reference type, yields `reference_object<T>`.
+ */
+template <typename T>
+using object_t
+    = detail::object_impl<neo_is_object(T), neo_is_array(T), neo_is_reference(T), neo_is_void(T)>::
+        template f<T>;
+
+}  // namespace neo
diff --git a/src/neo/detail/optional.hpp b/src/neo/optional.detail.hpp
similarity index 99%
rename from src/neo/detail/optional.hpp
rename to src/neo/optional.detail.hpp
index c959efe..4585641 100644
--- a/src/neo/detail/optional.hpp
+++ b/src/neo/optional.detail.hpp
@@ -1,7 +1,7 @@
 #pragma once
 
-#include "neo/type_traits.hpp"
 #include <neo/concepts.hpp>
+#include <neo/type_traits.hpp>
 
 #include <optional>
 
diff --git a/src/neo/optional.hpp b/src/neo/optional.hpp
index 448450d..92c7a3d 100644
--- a/src/neo/optional.hpp
+++ b/src/neo/optional.hpp
@@ -1,15 +1,18 @@
 #pragma once
 
+#include "./optional.detail.hpp"
+
 #include "./addressof.hpp"
 #include "./attrib.hpp"
-#include "./concepts.hpp"
+#include "./constexpr_union.hpp"
 #include "./declval.hpp"
-#include "./detail/optional.hpp"
 #include "./emplacement.hpp"
 #include "./invoke.hpp"
+#include "./object_t.hpp"
 #include "./returns.hpp"
 #include "./storage.hpp"
-#include "neo/type_traits.hpp"
+#include "./swap.hpp"
+#include "./type_traits.hpp"
 
 #include <compare>
 #include <cstddef>
@@ -40,14 +43,14 @@ class optional : public opt_detail::adl_operators {
     NEO_NO_UNIQUE_ADDRESS state_type _state = state_type();
 
     /// If we do not currently hold any value, throws bad_optional_access
-    void _check_has_value() const {
+    constexpr void _check_has_value() const {
         if (not has_value()) {
             opt_detail::throw_bad_optional();
         }
     }
 
     /// If we do not currently hold any value, terminate the program.
-    void _assert_has_value() const noexcept {
+    constexpr void _assert_has_value() const noexcept {
         if (not has_value()) {
             opt_detail::terminate_bad_optional();
         }
@@ -55,7 +58,7 @@ class optional : public opt_detail::adl_operators {
 
     /// Perform a copy-construct/copy-assignment, which may include moving, depending
     /// on the cvref of "other_storage" and the behavior of our optional_traits
-    void _assign(auto&& other_storage) {
+    constexpr void _assign(auto&& other_storage) {
         if (not has_value()) {
             // We have no value. We will take on the value of the other
             if (traits::has_value(other_storage)) {
@@ -175,6 +178,12 @@ class optional : public opt_detail::adl_operators {
         traits::construct(_state, NEO_FWD(args)...);
     }
 
+    constexpr explicit optional(std::in_place_t) noexcept
+        requires void_type<T>
+    {
+        traits::construct(_state);
+    }
+
     template <typename U>
     constexpr explicit(not convertible_to<U&&, T>)
         optional(U&& arg) noexcept(nothrow_constructible_from<U&&, T>)
@@ -231,7 +240,7 @@ class optional : public opt_detail::adl_operators {
     constexpr pointer       operator->() noexcept { return NEO_ADDRESSOF(**this); }
 
     constexpr explicit operator bool() const noexcept { return has_value(); }
-    constexpr bool has_value() const noexcept { return traits::has_value(_state); }
+    constexpr bool     has_value() const noexcept { return traits::has_value(_state); }
 
     constexpr auto value() & -> reference {
         _check_has_value();
@@ -398,8 +407,8 @@ class optional : public opt_detail::adl_operators {
     }
 
     template <typename F>
-        constexpr optional or_else(F&& fn) &&
-            requires movable<T>
+    constexpr optional or_else(F&& fn) &&
+        requires movable<T>
     {
         if (has_value()) {
             return *NEO_FWD(*this);
@@ -420,8 +429,8 @@ explicit optional(const T&) -> optional<T>;
 template <typename T>
 struct default_optional_state {
 public:
-    NEO_NO_UNIQUE_ADDRESS storage_for<T> storage;
-    bool                                 has_value = false;
+    NEO_NO_UNIQUE_ADDRESS constexpr_union<object_t<T>> onion;
+    bool                                               has_value = false;
 
     default_optional_state() = default;
 };
@@ -466,44 +475,43 @@ struct optional_traits {
 
     static constexpr bool trivial_copy        = copy_constructible<state_type>;
     static constexpr bool trivial_move        = move_constructible<state_type>;
-    static constexpr bool trivial_copy_assign = copyable<state_type>;
-    static constexpr bool trivial_move_assign = movable<state_type>;
+    static constexpr bool trivial_copy_assign = trivially_copyable<state_type>;
+    static constexpr bool trivial_move_assign = trivially_movable<state_type>;
 
     constexpr static bool has_value(const state_type& st) noexcept { return st.has_value; }
     constexpr static add_lvalue_reference_t<T> get(state_type& st) noexcept {
-        return st.storage.get();
+        return static_cast<add_lvalue_reference_t<T>>(st.onion._0);
     }
     constexpr static add_const_reference_t<T> get(const state_type& st) noexcept {
-        return st.storage.get();
+        return static_cast<add_const_reference_t<T>>(st.onion._0);
     }
     constexpr static void destroy(state_type& st) noexcept {
-        st.storage.destroy();
+        st.onion.template destroy<0>();
         st.has_value = false;
     }
     template <typename... Args>
     constexpr static void
     construct(state_type& st, Args&&... args) noexcept(nothrow_constructible_from<T, Args...>) {
-        st.storage.construct(NEO_FWD(args)...);
+        st.onion.template construct<0>(NEO_FWD(args)...);
         st.has_value = true;
     }
 
     template <typename O>
     constexpr static void copy(state_type& into, O&& from)  //
         noexcept(nothrow_constructible_from<T,
-                                            decltype(NEO_FWD(from).storage.get())>)  //
+                                            decltype(NEO_FWD(from).onion._0)>)  //
     {
-        into.storage.copy_from(NEO_FWD(from).storage);
-        into.has_value = true;
+        construct(into, NEO_FWD(from).onion._0);
     }
 
     template <typename O>
-    constexpr static void assign(state_type& into, O&& from)                              //
-        noexcept(std::is_nothrow_assignable_v<T, decltype(NEO_FWD(from).storage.get())>)  //
+    constexpr static void assign(state_type& into, O&& from)                         //
+        noexcept(std::is_nothrow_assignable_v<T, decltype(NEO_FWD(from).onion._0)>)  //
     {
-        into.storage.assign_from(NEO_FWD(from).storage);
+        into.onion._0 = NEO_FWD(from).onion._0;
     }
 
-    constexpr static void swap(state_type& a, state_type& b) { a.storage.swap(b.storage); }
+    constexpr static void swap(state_type& a, state_type& b) { neo::swap(a.onion._0, b.onion._0); }
 };
 
 /**
diff --git a/src/neo/pick_type.hpp b/src/neo/pick_type.hpp
index f1b3f00..00f5a77 100644
--- a/src/neo/pick_type.hpp
+++ b/src/neo/pick_type.hpp
@@ -1,208 +1,13 @@
 #pragma once
 
-#include <utility>
+#include "./meta.hpp"
 
 namespace neo {
 
-#define u64 unsigned long long
+using meta::find_type_v;
+using meta::find_type_in;
 
-/**
- * @brief Pick the Nth type from a variadic type list
- *
- * @tparam N The index to pick from
- *
- * Use the nested `from<Ts...>` struct to pass a variadic list of types
- */
-template <u64 N>
-struct pick_type;
+template <std::size_t N, typename L>
+using pick_type_of_t [[deprecated("Use neo::meta::at")]] = meta::at<L, N>;
 
-template <>
-struct pick_type<0> {
-    template <typename T, typename...>
-    struct from {
-        using type = T;
-    };
-};
-
-template <>
-struct pick_type<1> {
-    template <typename, typename T, typename...>
-    struct from {
-        using type = T;
-    };
-};
-
-template <>
-struct pick_type<2> {
-    template <typename, typename, typename T, typename...>
-    struct from {
-        using type = T;
-    };
-};
-
-template <>
-struct pick_type<3> {
-    template <typename, typename, typename, typename T, typename...>
-    struct from {
-        using type = T;
-    };
-};
-
-template <u64 N>
-requires(N >= 4 and N < 16) struct pick_type<N> {
-    template <typename, typename, typename, typename, typename... Tail>
-    struct from : pick_type<N - 4>::template from<Tail...> {};
-};
-
-template <u64 N>
-requires(N >= 16 and N < 64) struct pick_type<N> {
-    template <typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename... Tail>
-    struct from : pick_type<N - 16>::template from<Tail...> {};
-};
-
-template <u64 N>
-requires(N >= 64) struct pick_type<N> {
-    template <typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename,
-              typename... Tail>
-    struct from : pick_type<N - 64>::template from<Tail...> {};
-};
-
-/**
- * @brief Select the Nth type from the list of variadic typs
- *
- * @tparam N The index (zero-based)
- * @tparam Ts Some number of types to read from
- */
-template <u64 N, typename... Ts>
-using pick_type_t = typename pick_type<N>::template from<Ts...>::type;
-
-/**
- * @brief Pick the Nth type argument from a template specialization
- *
- * @tparam N The index to pick from
- */
-template <u64 N>
-struct pick_type_of {
-    /// Specify the template specialization to pick from
-    template <typename Seq>
-    struct from;
-
-    template <template <typename...> class L, typename... Ts>
-    struct from<L<Ts...>> : pick_type<N>::template from<Ts...> {};
-};
-
-/**
- * @brief Obtain the Nth template argument for the given template specialization
- *
- * @tparam N The index to pick (zero-based)
- * @tparam Seq A template specialization (Only type parameters are supported)
- */
-template <u64 N, typename Seq>
-using pick_type_of_t = typename pick_type_of<N>::template from<Seq>::type;
-
-namespace find_type_detail {
-
-template <u64 N, typename T, typename U>
-struct find_type_one {};
-
-template <u64 N, typename T>
-struct find_type_one<N, T, T> {
-    enum { value = N };
-};
-
-template <typename Seq, typename T, typename... Ts>
-struct finder;
-
-template <std::size_t... Ns, typename T, typename... Ts>
-struct finder<std::index_sequence<Ns...>, T, Ts...> : find_type_one<Ns, T, Ts>... {};
-
-}  // namespace find_type_detail
-
-template <typename Needle, typename... Ts>
-struct find_type : find_type_detail::finder<std::index_sequence_for<Ts...>, Needle, Ts...> {};
-
-template <typename Needle, typename... Ts>
-constexpr u64 find_type_v = find_type<Needle, Ts...>::value;
-
-#undef u64
-
-}  // namespace neo
+} // namespace neo
diff --git a/src/neo/pick_type.test.cpp b/src/neo/pick_type.test.cpp
deleted file mode 100644
index 5eef2a5..0000000
--- a/src/neo/pick_type.test.cpp
+++ /dev/null
@@ -1,32 +0,0 @@
-#include "./pick_type.hpp"
-
-#include "./tag.hpp"
-
-#include <cstddef>
-#include <utility>
-
-template <std::size_t>
-struct item {};
-
-template <typename Seq>
-struct p;
-
-template <std::size_t... I>
-struct p<std::index_sequence<I...>> {
-    using tag = neo::tag<item<I>...>;
-};
-
-#ifndef __INTELLISENSE__
-
-item<1>    f1 = neo::pick_type_of_t<1, p<std::make_index_sequence<4050>>::tag>{};
-item<0>    f2 = neo::pick_type_of_t<0, p<std::make_index_sequence<4050>>::tag>{};
-item<94>   f3 = neo::pick_type_of_t<94, p<std::make_index_sequence<4050>>::tag>{};
-item<940>  f4 = neo::pick_type_of_t<940, p<std::make_index_sequence<4050>>::tag>{};
-item<4047> f5 = neo::pick_type_of_t<4047, p<std::make_index_sequence<4050>>::tag>{};
-item<9845> f6 = neo::pick_type_of_t<9845, p<std::make_index_sequence<10'000>>::tag>{};
-// nth f     = 9;
-
-#endif
-
-// Required for executable linkage
-int main() {}
diff --git a/src/neo/platform.hpp b/src/neo/platform.hpp
index c911c09..60b45fb 100644
--- a/src/neo/platform.hpp
+++ b/src/neo/platform.hpp
@@ -2,6 +2,9 @@
 
 #include "./pp.hpp"
 
+#pragma push_macro("linux")
+#undef linux
+
 namespace neo {
 
 /*
@@ -302,3 +305,5 @@ constexpr void do_repr(auto out, operating_system_t const* value) noexcept {
 // clang-format on
 
 }  // namespace neo
+
+#pragma pop_macro("linux")
diff --git a/src/neo/ref.hpp b/src/neo/ref.hpp
index 7775aed..43b44ce 100644
--- a/src/neo/ref.hpp
+++ b/src/neo/ref.hpp
@@ -1,5 +1,6 @@
 #pragma once
 
+#include "./addressof.hpp"
 #include "./attrib.hpp"
 #include "./concepts.hpp"
 #include "./map_ref.hpp"
@@ -59,4 +60,36 @@ using wrap_if_reference_t [[deprecated("Use wrap_ref_member_t and ref_member")]]
     }                                                                                              \
     static_assert(true)
 
+/**
+ * @brief Defines an object-type that represents a non-nullable reference to another type. Acts
+ * as a non-nullable pointer in that assignment and comparison acts on the reference rather than
+ * the referred-to object.
+ *
+ * To get the underlying referred-to object, use a `static_cast` to get back to a C++ language
+ * reference type.
+ *
+ * @tparam T A reference type that we represent
+ */
+template <reference_type T>
+class reference_object {
+public:
+    using reference_type = T;
+    using pointer_type   = add_pointer_t<T>;
+
+public:
+    // "Bind" the new reference
+    constexpr reference_object(T ref) noexcept
+        : _pointer(NEO_ADDRESSOF(ref)) {}
+
+    // Return to the language-level reference type that we represent
+    NEO_ALWAYS_INLINE constexpr explicit operator T() const noexcept { return *_pointer; }
+
+    // Compare two references by comparing the wrapped object addresses
+    bool operator==(const reference_object&) const  = default;
+    auto operator<=>(const reference_object&) const = default;
+
+private:
+    pointer_type _pointer;
+};
+
 }  // namespace neo
diff --git a/src/neo/ref.test.cpp b/src/neo/ref.test.cpp
index 639c1d2..4f04db2 100644
--- a/src/neo/ref.test.cpp
+++ b/src/neo/ref.test.cpp
@@ -1,3 +1,4 @@
+#include <neo/concepts.hpp>
 #include <neo/ref.hpp>
 
 #include <catch2/catch.hpp>
@@ -24,7 +25,11 @@ static_assert(is_same_v<decltype(mref_v<const int&&>), int&&>);
 static_assert(is_same_v<decltype(mref_v<int&>), int&>);
 static_assert(is_same_v<decltype(mref_v<const int&>), int&>);
 
-#include <catch2/catch.hpp>
+static_assert(neo::equality_comparable<neo::reference_object<int&>>);
+static_assert(neo::totally_ordered<neo::reference_object<int&>>);
+static_assert(neo::copyable<neo::reference_object<int&>>);
+static_assert(neo::explicit_convertible_to<neo::reference_object<int&>, int&>);
+static_assert(neo::explicit_convertible_to<neo::reference_object<int&>, const int&>);
 
 // This is required in order to link in some configurations MSVC
 TEST_CASE("nil") {}
diff --git a/src/neo/swap.hpp b/src/neo/swap.hpp
new file mode 100644
index 0000000..07b80e0
--- /dev/null
+++ b/src/neo/swap.hpp
@@ -0,0 +1,56 @@
+#pragma once
+
+#include "./fwd.hpp"
+#include "./type_traits.hpp"
+
+namespace neo {
+
+namespace _swap {
+
+// Detect an ADL-visible overload of swap()
+template <typename T, typename U>
+concept has_adl_swap
+    = (class_or_enum_type<remove_cvref_t<T>> or class_or_enum_type<remove_cvref_t<U>>)  //
+    and requires(T&& left, T&& right) { swap(NEO_FWD(left), NEO_FWD(right)); };
+
+// Detect support for swapping via a temporary
+template <typename T>
+concept has_shuffle_swap = not has_adl_swap<T&, T&> and requires(T& t) {
+    T(NEO_MOVE(t));
+    t = NEO_MOVE(t);
+};
+
+// The swapping function
+struct fn {
+    /**
+     * @brief Swap two objects via an ADL-visible custom swap() function
+     */
+    template <typename T, typename U>
+        requires has_adl_swap<T, U>
+    constexpr void operator()(T&& t, U&& u) const noexcept(noexcept(swap(NEO_FWD(t), NEO_FWD(u)))) {
+        (void)swap(NEO_FWD(t), NEO_FWD(u));
+    }
+
+    /**
+     * @brief Swap two objects by constructing a temporary and exchanging through it
+     */
+    template <typename T>
+        requires has_shuffle_swap<T>
+    constexpr void operator()(T& t, T& u) const
+        noexcept(noexcept(t = NEO_MOVE(u)) and noexcept(T(NEO_MOVE(u)))) {
+        T tmp = NEO_MOVE(t);
+        t     = NEO_MOVE(u);
+        u     = NEO_MOVE(tmp);
+    }
+};
+
+}  // namespace _swap
+
+inline namespace _cpo {
+/**
+ * @brief CPO implementation of std::swap()
+ */
+inline constexpr auto swap = _swap::fn{};
+}  // namespace _cpo
+
+}  // namespace neo
diff --git a/src/neo/testing.hpp b/src/neo/testing.hpp
new file mode 100644
index 0000000..f848b60
--- /dev/null
+++ b/src/neo/testing.hpp
@@ -0,0 +1,40 @@
+#pragma once
+
+#include <neo/meta.hpp>
+
+namespace neo::testing {
+
+struct asserter {
+    consteval void operator()(bool cond) const {
+        if (not cond) {
+            throw;
+        }
+    }
+};
+
+/**
+ * @brief Declare a compile-time test case. Must be initialized with an invocable
+ * that is `consteval` and accepts an `asserter` as an argument.
+ */
+struct [[maybe_unused]] cx_test_case {
+    template <typename F>
+    consteval cx_test_case(F fn) {
+        static_cast<void>(fn(asserter{}));
+    }
+};
+
+/**
+ * @brief Declare a compile-time test case that executes the test function once
+ * for each given type argument, passing a `meta::tag<T>` as the second argument for each function
+ *
+ * @tparam Ts The types to pass to the test case function.
+ */
+template <typename... Ts>
+struct [[maybe_unused]] cx_test_case_foreach {
+    template <typename F>
+    consteval cx_test_case_foreach(F fn) {
+        (static_cast<void>(fn(asserter{}, meta::tag_v<Ts>)), ...);
+    }
+};
+
+}  // namespace neo::testing
\ No newline at end of file
diff --git a/src/neo/testing.test.cpp b/src/neo/testing.test.cpp
new file mode 100644
index 0000000..0f7dfc5
--- /dev/null
+++ b/src/neo/testing.test.cpp
@@ -0,0 +1,16 @@
+#include "./testing.hpp"
+#include <neo/meta.hpp>
+
+#include <concepts>
+
+int main() {}
+
+neo::testing::cx_test_case SimpleTest = [](auto check) consteval {
+    check(true);
+    check(not false);
+};
+
+neo::testing::cx_test_case_foreach<int, double, void, int> ForEachType
+    = []<typename T>(auto check, neo::meta::tag<T>) consteval {
+          check(std::same_as<T, int> or std::same_as<T, void> or std::same_as<T, double>);
+      };
diff --git a/src/neo/type_traits.hpp b/src/neo/type_traits.hpp
index d8cdd28..62f8983 100644
--- a/src/neo/type_traits.hpp
+++ b/src/neo/type_traits.hpp
@@ -131,6 +131,18 @@ DECL_TRAIT_CONCEPT(null_pointer, neo_is_null_pointer);
 #define neo_is_array NEO_TTRAIT_BUILTIN_OR_VARTMPL(__is_array, ::neo::detail::is_array_v)
 DECL_TRAIT_CONCEPT(array_type, neo_is_array);
 
+/**
+ * @brief Match a type which is an array of known bounds
+ */
+template <typename T>
+concept bounded_array_type = array_type<T> and detail::is_bounded_array_v<T>;
+
+/**
+ * @brief Match a type which is an array of unknown boundss
+ */
+template <typename T>
+concept unbounded_array_type = array_type<T> and detail::is_unbounded_array_v<T>;
+
 #define neo_is_const NEO_TTRAIT_BUILTIN_OR_VARTMPL(__is_const, ::neo::detail::is_const_v)
 DECL_TRAIT_CONCEPT(const_type, neo_is_const);
 
@@ -163,6 +175,9 @@ DECL_TRAIT_CONCEPT(union_type, neo_is_union);
 #define neo_is_class NEO_TTRAIT_BUILTIN_OR_VARTMPL(__is_class, ::std::is_class_v)
 DECL_TRAIT_CONCEPT(class_type, neo_is_class);
 
+template <typename T>
+concept class_or_enum_type = class_type<T> or enum_type<T>;
+
 #define neo_is_empty NEO_TTRAIT_BUILTIN_OR_VARTMPL(__is_empty, ::std::is_empty_v)
 DECL_TRAIT_CONCEPT(empty_type, neo_is_empty);
 
@@ -175,7 +190,7 @@ DECL_TRAIT_CONCEPT(lvalue_reference_type, neo_is_lvalue_reference);
 DECL_TRAIT_CONCEPT(rvalue_reference_type, neo_is_rvalue_reference);
 
 #define neo_is_reference(...)                                                                      \
-    neo_is_lvalue_reference(__VA_ARGS__) or neo_is_rvalue_reference(__VA_ARGS__)
+    (neo_is_lvalue_reference(__VA_ARGS__) or neo_is_rvalue_reference(__VA_ARGS__))
 
 template <typename T>
 concept reference_type = lvalue_reference_type<T> or rvalue_reference_type<T>;
@@ -340,6 +355,15 @@ DECL_TRAIT_CONCEPT(object_type, neo_is_object);
 #define neo_is_trivially_assignable                                                                \
     NEO_TTRAIT_BUILTIN_OR_VARTMPL(__is_trivially_assignable, ::std::is_trivially_assignable_v)
 
+template <typename T>
+concept member_function_pointer = neo_is_member_function_pointer(T);
+
+template <typename T>
+concept member_object_pointer = neo_is_member_object_pointer(T);
+
+template <typename T>
+concept member_pointer = member_function_pointer<T> or member_object_pointer<T>;
+
 namespace detail {
 
 template <typename T>
@@ -672,6 +696,30 @@ struct detail::common_reference {
                       common_reference_t<common_reference_t<T, U>, common_reference_t<Vs...>>> {};
 };
 
+namespace detail {
+
+/// Add a level of indirection to prevent type_identity_t from being deduced,
+/// while also permforming better than a naive std::type_identity.
+template <bool>
+struct type_identity {
+    template <typename T>
+    using f = T;
+};
+
+}  // namespace detail
+
+/**
+ * @brief Yields the exact type given as the template argument. Inhibits argument deduction.
+ */
+template <typename T>
+using type_identity_t = detail::type_identity<void_type<T>>::template f<T>;
+
+/**
+ * @brief Wrap a template parameter in a context to guard it from template argument deduction
+ */
+template <typename T>
+using nondeduced = type_identity_t<T>;
+
 }  // namespace neo
 
 #undef BOOL
diff --git a/src/neo/type_traits.test.cpp b/src/neo/type_traits.test.cpp
index 81457ad..3803bad 100644
--- a/src/neo/type_traits.test.cpp
+++ b/src/neo/type_traits.test.cpp
@@ -60,3 +60,17 @@ static_assert(neo::same_as<neo::common_reference_t<int&, int>, std::common_refer
 static_assert(
     neo::same_as<neo::common_reference_t<int&, double&>, std::common_reference_t<int&, double&>>);
 static_assert(neo::same_as<neo::common_reference_t<int&, double&, float&>, double>);
+
+// A function that refuses to deduce its argument:
+template <typename T>
+void nondeduced_param(neo::nondeduced<T>) {}
+
+// Test that argument deducation fails:
+template <typename T>
+concept test_nondeduced = requires(T x) { nondeduced_param(x); };
+static_assert(not test_nondeduced<int>);
+
+// Check with that an explicit argument succeeds:
+template <typename T>
+concept test_nondeduced_2 = requires(T x) { nondeduced_param<T>(x); };
+static_assert(test_nondeduced_2<int>);
diff --git a/src/neo/unit.hpp b/src/neo/unit.hpp
index dd7815c..d26edd3 100644
--- a/src/neo/unit.hpp
+++ b/src/neo/unit.hpp
@@ -13,19 +13,21 @@ namespace neo {
  * Explicit-convertible from anything.
  */
 struct unit {
+    // Default-constructor is a no-op
     constexpr unit() noexcept = default;
+    // Construct from a literal zero, also a no-op
     constexpr unit(decltype(nullptr)) noexcept {}
+    // Explicitly convert from anything (just discards the argument)
     template <typename X>
     constexpr explicit unit(X&&) noexcept {}
 
-    constexpr bool operator==(unit) const noexcept { return true; }
-
-    constexpr std::strong_ordering operator<=>(unit) const noexcept {
-        return std::strong_ordering::equal;
-    }
+    // Default equality for a unit is always `true`
+    constexpr bool operator==(unit const&) const noexcept = default;
+    // Default ordering for a unit is always `equal`
+    constexpr std::strong_ordering operator<=>(unit const&) const noexcept = default;
 };
 
-namespace unit_detail {
+namespace _unit_detail {
 
 template <bool IsVoid>
 struct make_nonvoid {
@@ -39,12 +41,12 @@ struct make_nonvoid<true> {
     using f = unit;
 };
 
-}  // namespace unit_detail
+}  // namespace _unit_detail
 
 /**
  * @brief Ensures that `T` is not void. If given `void`, returns `neo::unit`
  */
 template <typename T>
-using make_nonvoid_t = unit_detail::make_nonvoid<void_type<T>>::template f<T>;
+using nonvoid_t = _unit_detail::make_nonvoid<void_type<T>>::template f<T>;
 
 }  // namespace neo
diff --git a/src/neo/unit.test.cpp b/src/neo/unit.test.cpp
index 26a4edc..d4ea0cf 100644
--- a/src/neo/unit.test.cpp
+++ b/src/neo/unit.test.cpp
@@ -3,24 +3,50 @@
 
 #include <catch2/catch.hpp>
 
+#include <concepts>
+
 static_assert(neo::regular<neo::unit>);
 static_assert(neo::totally_ordered<neo::unit>);
 static_assert(neo::unit{} == neo::unit{});
 
+TEST_CASE("make_nonvoid_t") {
+    STATIC_REQUIRE(std::same_as<neo::nonvoid_t<int>, int>);
+    STATIC_REQUIRE(std::same_as<neo::nonvoid_t<neo::unit>, neo::unit>);
+    STATIC_REQUIRE(std::same_as<neo::nonvoid_t<void>, neo::unit>);
+    STATIC_REQUIRE(std::same_as<neo::nonvoid_t<const void>, neo::unit>);
+    STATIC_REQUIRE(std::same_as<neo::nonvoid_t<const void*>, const void*>);
+}
+
 TEST_CASE("Default construct") {
-    neo::unit a, b;
-    CHECK(a == b);
-    CHECK_FALSE(a != b);
+    constexpr neo::unit a, b;
+    STATIC_REQUIRE(a == b);
+    STATIC_REQUIRE_FALSE(a != b);
 }
 
 TEST_CASE("Copy") {
-    neo::unit a;
-    auto      b = a;
-    CHECK(a == b);
+    constexpr neo::unit a;
+    constexpr auto      b = a;
+    STATIC_REQUIRE(a == b);
 }
 
 TEST_CASE("Order") {
-    neo::unit a, b;
-    CHECK(a <= b);
-    CHECK_FALSE(a < b);
+    constexpr neo::unit a, b;
+    STATIC_REQUIRE(a <= b);
+    STATIC_REQUIRE_FALSE(a < b);
+}
+
+TEST_CASE("Construct from zero") {
+    constexpr neo::unit a = 0;
+    STATIC_REQUIRE(a == a);
+}
+
+TEST_CASE("Construct from arbitrary objects") {
+    constexpr neo::unit a(42);
+    STATIC_REQUIRE(a == a);
+
+    constexpr neo::unit b(0);
+    STATIC_REQUIRE(a == b);
+
+    constexpr neo::unit c("hey");
+    STATIC_REQUIRE(c == b);
 }
diff --git a/src/neo/variant.detail.hpp b/src/neo/variant.detail.hpp
new file mode 100644
index 0000000..c9c76bb
--- /dev/null
+++ b/src/neo/variant.detail.hpp
@@ -0,0 +1,156 @@
+#pragma once
+
+#include <neo/concepts.hpp>
+#include <neo/object_t.hpp>
+#include <neo/swap.hpp>
+
+#include <compare>  // operator<=>
+#include <cstdint>  // std::uint16_t
+#include <utility>  // emplacement tags
+
+namespace neo::_variant_detail {
+
+/// Yields `true` for types that are emplacement tags (in_place_type, in_place_index)
+template <typename T>
+constexpr bool is_emplacement_tag = false;
+
+template <typename T>
+constexpr bool is_emplacement_tag<std::in_place_type_t<T>> = true;
+
+template <std::size_t I>
+constexpr bool is_emplacement_tag<std::in_place_index_t<I>> = true;
+
+/**
+ * @brief An empty psuedo-integral type that is always equal to zero, used for
+ * indexing in a variant of a single alternative.
+ */
+struct always_zero {
+    constexpr always_zero() = default;
+
+    consteval explicit always_zero(std::size_t n) {
+        if (n != 0) {
+            throw;
+        }
+    }
+
+    template <neo::integral I>
+    constexpr explicit operator I() const noexcept {
+        return static_cast<I>(0);
+    }
+
+    constexpr bool operator==(neo::integral auto i) const noexcept { return i == 0; }
+    constexpr std::strong_ordering operator<=>(neo::integral auto i) const noexcept {
+        return 0 <=> i;
+    }
+
+    bool operator==(always_zero const&) const noexcept  = default;
+    auto operator<=>(always_zero const&) const noexcept = default;
+};
+
+template <typename... Ts>
+using pick_index_type
+    = conditional_t<sizeof...(Ts) == 1,
+                    always_zero,
+                    conditional_t<sizeof...(Ts) < 256, std::uint8_t, std::uint16_t>>;
+
+// If we have no destructors to execute, don't define one for ourself
+template <typename... Ts>
+concept enable_nontrivial_dtor = not(neo_is_trivially_destructible(object_t<Ts>) and ...);
+
+// If any of our alts is not *trivially* copyable, but all alts ARE copyable, define
+// a non-trivial copy constructor
+template <typename... Ts>
+concept enable_nontrivial_copy_construct = not(trivially_copy_constructible<object_t<Ts>> and ...)
+    and (copy_constructible<object_t<Ts>> and ...);
+
+// Define a copy-assignment if:
+// - All alts are copyable
+// - AND one of:
+//      - Any alt is not trivially destructible (since we'll need to destroy it)
+//      - Any alt is not trivially copy assignable (Since we may need to assign-thru)
+//      - Any alt is not trivially copy constructible (Since we may need to copy)
+template <typename... Ts>
+concept enable_nontrivial_copy_assign =                       //
+    (enable_nontrivial_dtor<Ts...>                            //
+     or not(trivially_copy_assignable<object_t<Ts>> and ...)  //
+     or enable_nontrivial_copy_construct<Ts...>)              //
+    and(copyable<object_t<Ts>> and ...);
+
+// If any of our alts is not *trivially* movable, but all alts ARE movable, define
+// a non-trivial move constructor
+template <typename... Ts>
+concept enable_nontrivial_move_construct =  //
+    not(trivially_move_constructible<object_t<Ts>> and ...)
+    and (move_constructible<object_t<Ts>> and ...);
+
+// Define a move-assignment if:
+// - All alts are movable
+// - AND one of:
+//      - Any alt is not trivially destructible (since we'll need to destroy it)
+//      - Any alt is not trivially move assignable (Since we may need to assign-thru)
+//      - Any alt is not trivially move-constructible (Since we may need to move-construct it)
+template <typename... Ts>
+concept enable_nontrivial_move_assign =                       //
+    (enable_nontrivial_dtor<Ts...>                            //
+     or not(trivially_move_assignable<object_t<Ts>> and ...)  //
+     or enable_nontrivial_move_construct<Ts...>)              //
+    and(move_assignable<object_t<Ts>> and ...);
+
+/**
+ * @brief Helper used select the "best" alternative to a candidate conversion.
+ *
+ * @tparam Args A type list for the candidate conversion targets
+ */
+template <typename Args, typename Seq = std::make_index_sequence<meta::len_v<Args>>>
+struct select_conversion;
+
+/**
+ * @brief Defines a single conversion function candidate
+ *
+ * @tparam std::size_t N the index of the alternative
+ * @tparam Arg The argument type of the overload
+ */
+template <std::size_t N, typename To>
+struct select_conversion_base {
+    // This conversion is only viable if the conversion is defined AND non-narrowing.
+    // Return the index of the conversion candidate (given via `N`)
+    template <non_narrowing_convertible_to<To> From>
+    static meta::val<N> select(To);
+};
+
+template <neo_ttparam L, typename... Args, std::size_t... Ns>
+struct select_conversion<L<Args...>, std::index_sequence<Ns...>>
+    // Zip the indices and the conversion candidates together in a variadic base class list:
+    : select_conversion_base<Ns, Args>... {
+    // Pull the base class functions to form the overload set
+    using select_conversion_base<Ns, Args>::select...;
+};
+
+/**
+ * @brief Find the zero-based index of the "best" conversion available from `From` to one of
+ * `Ts...`. Yields a type with a nested `::value` specifying the zero-based index of
+ * the selected conversion target in `Ts...`
+ *
+ * @tparam From The type which is being converted-from
+ * @tparam Ts The candidate conversion targets
+ *
+ * Requires that EXACTLY one of the `Ts` be a valid target for a non-narrowing conversion from
+ * `From`.
+ *
+ * If a conversion target is `void`, it is replaced with `neo::unit` for the overload argument.
+ */
+template <typename From, typename... Ts>
+    requires(not is_emplacement_tag<remove_cvref_t<From>>)
+using best_conversion_index_t
+    = decltype(select_conversion<meta::list<nonvoid_t<Ts>...>>::template select<From>(
+        NEO_DECLVAL(From)));
+
+/**
+ * @brief Defined later in variant.hpp
+ *
+ * @tparam bool Unused template parameter, only used to defer inspection of the variant base
+ */
+template <bool Unused>
+struct variant_operators;
+
+}  // namespace neo::_variant_detail
diff --git a/src/neo/variant.hpp b/src/neo/variant.hpp
new file mode 100644
index 0000000..e5453b7
--- /dev/null
+++ b/src/neo/variant.hpp
@@ -0,0 +1,570 @@
+#pragma once
+
+#include "./variant.detail.hpp"
+
+#include <neo/compare.hpp>
+#include <neo/constexpr_union.hpp>
+#include <neo/optional.hpp>  // optional<void>
+#include <neo/unit.hpp>      // unit/nonvoid_t
+
+#include <compare>
+#include <cstddef>
+#include <utility>
+
+namespace neo {
+
+/**
+ * @brief A type-safe tagged sum type. A leaner+faster alternative to std::variant.
+ *
+ * In addition to regular object types, supports reference types and `void` types.
+ * The assignment behavior of reference types is to perform a rebinding of the held
+ * reference. A `void` alternative acts like an empty unit type (akin to std::monostate)
+ */
+template <typename... Ts>
+class variant : _variant_detail::variant_operators<sizeof...(Ts) == 0 or true> {
+    friend _variant_detail::variant_operators<true>;
+
+    // We carefully choose between using object_t and nonvoid_t throughout. nonvoid_t
+    // will map `void` to `unit`, but leave reference types as reference types. `object_t`
+    // will map `void` to `unit` and changes reference types to `reference_object`, which
+    // treats reference more like non-nullable pointers which can be rebound and compared without
+    // touching the referred-to object.
+
+    // In constructor contexts, `nonvoid_t` is preferred since it is lighter weight, but in
+    // assignment, storage, and comparison, we use `object_t` so that we get "pointer-like"
+    // semantics out of our references.
+
+    // Extracting the first type once and reusing it is actually measurably more compile-time
+    // efficient than calling `pack_at<0, ...>` multiple times.
+    using _first_type = nonvoid_t<meta::pack_at<0, Ts...>>;
+
+public:
+    // Yield the Nth alternative type for the variant
+    template <std::size_t N>
+    using nth_type = meta::pack_at<N, Ts...>;
+
+    /**
+     * @brief Default constructor for the variant type. Default-constructs to the first alternative.
+     *
+     * This constructor requires that the first alternative be default-constructible.
+     */
+    constexpr variant() noexcept(noexcept(_first_type()))
+        requires neo::default_initializable<_first_type>
+    {
+        _storage.nil.~unit();
+        _storage.template construct<0>();
+        // Our _index is already default-assigned to zero
+    }
+
+    /**
+     * @brief Emplacement constructor for the Nth alternative
+     *
+     * @param tag The in-place-index tag that selects which alternative to construct and activate
+     * @param args... The arguments to pass to the constructor of the underlying alternative
+     */
+    template <std::size_t N, typename... Args, typename T = nth_type<N>>
+    constexpr explicit variant(std::in_place_index_t<N>,
+                               Args&&... args)  //
+        noexcept(noexcept(nonvoid_t<T>(NEO_FWD(args)...))) {
+        _storage.nil.~unit();
+        _storage.template construct<N>(NEO_FWD(args)...);
+        this->_index = index_type(N);
+    }
+
+    /**
+     * @brief In-place-by-type constructor. The requested type must occur exactly once in `Ts...`
+     *
+     * @param tag The in-place-type tag that selects which alternative to construct and activate
+     * @param args... The arguments to pass to the constructor of the underlying alternative
+     */
+    template <typename T, typename... Args, std::size_t N = meta::find_type_v<T, Ts...>>
+        requires((weak_same_as<T, Ts> + ...) == 1)
+    NEO_ALWAYS_INLINE constexpr explicit variant(std::in_place_type_t<T>, Args&&... args)  //
+        noexcept(noexcept(nonvoid_t<T>(NEO_FWD(args)...)))
+        : variant(std::in_place_index<N>, NEO_FWD(args)...) {}
+
+    /**
+     * @brief Alternative conversion constructor.
+     *
+     * Converts from an arbitrary value to the variant alternative that most closely
+     * matches it according to overload resolution. Narrowing conversions are never considered
+     * (this saves us from string-literal -> bool conversions, among other things). If the
+     * conversion is ambiguous, this constructor is not considered.
+     *
+     * This constructor is explicit if the given argument is not implicitly convertible
+     * to the selected alternative.
+     *
+     * This constructor is never considered when the argument is an emplacement tag
+     */
+    template <unalike<variant> Arg,
+              std::size_t      N = _variant_detail::best_conversion_index_t<Arg, Ts...>::value,
+              typename T         = nth_type<N>>
+    explicit(not implicit_convertible_to<Arg, nonvoid_t<T>>)  //
+        constexpr variant(Arg&& arg) noexcept(noexcept(nonvoid_t<T>(NEO_FWD(arg)))) {
+        _storage.nil.~unit();
+        _storage.template construct<N>(NEO_FWD(arg));
+        this->_index = index_type(N);
+    }
+
+    /**
+     * @brief Conversion assignment operator. Selects the best conversion
+     * according to the same rules as our converting constructor.
+     *
+     * If the variant currently holds the candidate conversion alternative, then
+     * the alternative will be updated in-place. Otherwise, will `emplace` a
+     * new instance of the target alternative, destroying the old one.
+     */
+    template <unalike<variant> Arg,
+              std::size_t      N = _variant_detail::best_conversion_index_t<Arg, Ts...>::value,
+              typename T         = nth_type<N>>
+        requires assignable_from<object_t<T>, Arg>
+    constexpr variant& operator=(Arg&& other)
+        // Noexcept if:
+        noexcept(
+            // Assignment of the chosen alt is noexcept,
+            noexcept(NEO_DECLVAL(object_t<T>&) = NEO_FWD(other))
+                // and construction of the chosen alt is noexcept
+                and noexcept(nonvoid_t<T>(NEO_FWD(other)))) {
+        if (this->index() == N) {
+            // We currently hold the alternative that would be the best candidate conversion,
+            // so do an assign-through to the held object.
+            this->_storage.template get<N>() = NEO_FWD(other);
+        } else {
+            // We do not hold the requested alternative. Instead, destroy what we
+            // are holding and emplace a new instance of the conversion target:
+            this->emplace<N>(NEO_FWD(other));
+        }
+        return *this;
+    }
+
+    /**
+     * @brief Emplace a new instance of the Nth alternative within the variant.
+     * The existing alternative is destroyed before the new alternative is emplaced.
+     *
+     * A reference to the constructed value is returned.
+     *
+     * Unlike std::variant, this variant has no valueless_by_exception state. In
+     * a rare situation where the strong exception safety guarantee cannot be met,
+     * the variant will call std::terminate().
+     */
+    template <std::size_t N,
+              typename... Args,
+              typename T   = nth_type<N>,
+              typename Ret = add_lvalue_reference_t<T>>
+    constexpr Ret emplace(Args&&... args)
+        // We throw if the constructor may throw:
+        noexcept(noexcept(nonvoid_t<T>(NEO_FWD(args)...)) or not move_constructible<nonvoid_t<T>>)
+        requires constructible_from<nonvoid_t<T>, Args...>
+    {
+        using obj_t = nonvoid_t<T>;
+        if constexpr (noexcept(obj_t(NEO_FWD(args)...)) or not move_constructible<obj_t>) {
+            // We are calling a no-throw constructor OR there is no available move constructor.
+            // This block will never throw an exception, but may terminate()
+            // Destroy the current value.
+            this->_destroy_current();
+            // Update the index
+            this->_index = index_type(N);
+            // If this constructor throws, it means that there is no valid move-constructor, then we
+            // will call std::terminate()
+            return static_cast<Ret>(_storage.template construct<N>(NEO_FWD(args)...));
+        } else {
+            // The constructor is possibly-throwing, but we have a valid move-constructor
+            // to use. Do the possibly-throwing construct:
+            obj_t obj(NEO_FWD(args)...);
+            // We constructed without throwing. Now we are ready to swap alternatives.
+            // Destroy the current alternative:
+            this->_destroy_current();
+            // Update our index:
+            this->_index = index_type(N);
+            try {
+                // If the move-constructor throws, we've already cleared out our current
+                // alternative and have updated our index, so there's no going back, and
+                // we'll terminate(). (No valueless_by_exception() allowed)
+                return static_cast<Ret>(_storage.template construct<N>(NEO_MOVE(obj)));
+            } catch (...) {
+                std::terminate();
+            }
+        }
+    }
+
+    /**
+     * @brief Emplace a new instance of the given alternative within the variant.
+     * The existing alternative is destroyed before the new alternative is emplaced.
+     * The requested alternative must occur exactly once in `Ts...`
+     *
+     * A reference to the constructed value is returned.
+     *
+     * Unlike std::variant, this variant has no valueless_by_exception state. In
+     * a rare situation where the strong exception safety guarantee cannot be met,
+     * the variant will call std::terminate().
+     *
+     * @tparam Alt The alternative to be constructed
+     */
+    template <typename Alt, std::size_t N = meta::find_type_in<Alt, variant>, typename... Args>
+        requires((weak_same_as<Alt, Ts> + ...) == 1) and constructible_from<nonvoid_t<Alt>, Args...>
+    constexpr add_lvalue_reference_t<Alt>
+    emplace(Args&&... args) noexcept(nothrow_constructible_from<nonvoid_t<Alt>, Args...>) {
+        return this->template emplace<N>(NEO_FWD(args)...);
+    }
+
+    /**
+     * @brief Get the zero-based index of the currently active alternative
+     */
+    [[nodiscard]] constexpr std::size_t index() const noexcept {
+        return static_cast<std::size_t>(this->_index);
+    }
+
+    /**
+     * @brief Obtain an optional reference to the Nth alternative stored by this type
+     *
+     * @tparam N The index of the alternative to seek.
+     * @return An optional-ref-like to the Nth alternative (a pointer or optional<void>).
+     * Returns a false-ish value if the requested alternative is not active.
+     *
+     * @note To get the alternative by type, use `neo/get.hpp` with `try_get_as`
+     */
+    template <std::size_t N>
+        requires((N < sizeof...(Ts)))
+    [[nodiscard]] constexpr auto try_get() noexcept {
+        return this->template _do_try_get<N, nth_type<N>>(*this);
+    }
+
+    template <std::size_t N>
+        requires((N < sizeof...(Ts)))
+    [[nodiscard]] constexpr auto try_get() const noexcept {
+        return this->template _do_try_get<N, const nth_type<N>>(*this);
+    }
+
+private:
+    // The type used to represent the active variant member tag.
+    using index_type = _variant_detail::pick_index_type<Ts...>;
+    // An index sequence, for convenience
+    using index_sequence = std::make_index_sequence<sizeof...(Ts)>;
+
+    // The storage union. Being the first member ensures that `try_get` can be optimized away as
+    // compile-time simple pointer conversion
+    NEO_NO_UNIQUE_ADDRESS constexpr_union<object_t<Ts>...> _storage;
+    // The currently active member is designated by the value of this index
+    NEO_NO_UNIQUE_ADDRESS index_type _index = index_type(0);
+
+public:
+    ~variant() = default;
+    // Only define a non-default destructor if any alternative has a non-trivial destructor
+    NEO_CONSTEXPR_DESTRUCTOR ~variant()
+        requires _variant_detail::enable_nontrivial_dtor<Ts...>
+    {
+        this->_destroy_current();
+    }
+
+    variant(const variant&)            = default;
+    variant(variant&&)                 = default;
+    variant& operator=(const variant&) = default;
+    variant& operator=(variant&&)      = default;
+
+    constexpr variant(const variant& other)
+        // Noexcept if every copy-ctor is noexcept
+        noexcept((noexcept(nonvoid_t<Ts>(NEO_DECLVAL(const nonvoid_t<Ts>&))) and ...))
+        requires _variant_detail::enable_nontrivial_copy_construct<Ts...>
+    {
+        this->_copy_anew_from(*this, other, index_sequence{});
+    }
+
+    constexpr variant(variant&& other)
+        // Noexcept if every move-ctor is noexcept
+        noexcept((noexcept(nonvoid_t<Ts>(NEO_DECLVAL(nonvoid_t<Ts>&&))) and ...))
+        requires _variant_detail::enable_nontrivial_move_construct<Ts...>
+    {
+        this->_copy_anew_from(*this, NEO_MOVE(other), index_sequence{});
+    }
+
+    constexpr variant& operator=(const variant& other)
+        // Noexcept if:
+        noexcept(
+            // Every copy-assignment is noexcept:
+            (noexcept(NEO_DECLVAL(object_t<Ts>&) = NEO_DECLVAL(object_t<Ts> const&)) and ...)
+            // And every copy-ctor is noexcept
+            and (noexcept(nonvoid_t<Ts>(NEO_DECLVAL(const nonvoid_t<Ts>&))) and ...))
+        requires _variant_detail::enable_nontrivial_copy_assign<Ts...>
+    {
+        this->_copy_assign_from(*this, other, index_sequence{});
+        return *this;
+    }
+
+    constexpr variant& operator=(variant&& other)
+        // Noexcept if:
+        noexcept(
+            // Every move-assignment is noexcept:
+            (noexcept(NEO_DECLVAL(object_t<Ts>&) = NEO_DECLVAL(object_t<Ts>&&)) and ...)
+            // And every move-ctor is noexcept
+            and (noexcept(nonvoid_t<Ts>(NEO_DECLVAL(nonvoid_t<Ts>&&))) and ...))
+        requires _variant_detail::enable_nontrivial_move_assign<Ts...>
+    {
+        this->_copy_assign_from(*this, NEO_MOVE(other), index_sequence{});
+        return *this;
+    }
+
+    /**
+     * @brief Destroy the currrently held variant alternative.
+     */
+    constexpr void _destroy_current() noexcept {
+        if constexpr (_variant_detail::enable_nontrivial_dtor<Ts...>) {
+            this->_do_destroy_current(*this, index_sequence{});
+        }
+    }
+};
+
+namespace _variant_detail {
+
+template <bool>
+struct variant_operators {
+    /**
+     * @brief Define an ADL-visible swap() function between variants.
+     *
+     * Requires that all alternatives are swappable. If the two variants hold
+     * the same alternative, then alternatives are swapped in-place. Otherwise,
+     * the standard exchange-swap occurs between the three variants.
+     */
+    template <typename... Ts>
+    constexpr friend void swap(variant<Ts...>& left, variant<Ts...>& right) noexcept(
+        // All sub-swaps are noexcept?
+        (noexcept(neo::swap(NEO_DECLVAL(object_t<Ts>&), NEO_DECLVAL(object_t<Ts>&))) and ...)
+        // all objects are nothrow-move-constructible?
+        and (nothrow_constructible_from<nonvoid_t<Ts>, nonvoid_t<Ts>&&> and ...))
+        // Require all objects to be swappable and move-constructible
+        requires(swappable<object_t<Ts>> and ...) and (move_constructible<nonvoid_t<Ts>> and ...)
+    {
+        _impl_swap(left, right, std::index_sequence_for<Ts...>{});
+    }
+
+    template <typename... Ts>
+        requires(equality_comparable<object_t<Ts>> and ...)
+    friend constexpr bool operator==(const variant<Ts...>&             self,
+                                     nondeduced<variant<Ts...> const&> other) noexcept {
+        return _compare_eq(self, other, std::index_sequence_for<Ts...>{});
+    }
+
+    template <typename... Ts>
+        requires(totally_ordered<object_t<Ts>> and ...)
+    friend constexpr auto operator<=>(const variant<Ts...>&             self,
+                                      const nondeduced<variant<Ts...>>& other) noexcept {
+        return _compare_order(self, other, std::index_sequence_for<Ts...>{});
+    }
+
+    // Implements order comparisong
+    template <std::size_t... Ns, typename... Ts>
+    static constexpr auto _compare_order(const variant<Ts...>& self,
+                                         const variant<Ts...>& other,
+                                         std::index_sequence<Ns...>) noexcept {
+        auto this_index  = self.index();
+        auto other_index = other.index();
+        // If the indices are not the same, immedately record them as non-equal.
+        std::common_comparison_category_t<std::compare_three_way_result_t<object_t<Ts>>...> ret
+            = this_index <=> other_index;
+        // Compare until we get to the active alternative:
+        static_cast<void>((
+            (ret != 0  // Don't proceed if we've already labeled ourself as unequal
+             or ((this_index == Ns)
+                 and 0
+                     != (ret = (std::compare_strong_order_fallback(self._storage.template get<Ns>(),
+                                                                   other._storage
+                                                                       .template get<Ns>())))))
+            or ...));
+        // Return the result:
+        return ret;
+    }
+
+    // Implements equality comparison
+    template <std::size_t... Ns, typename... Ts>
+    static constexpr bool _compare_eq(const variant<Ts...>& self,
+                                      const variant<Ts...>& other,
+                                      std::index_sequence<Ns...>) noexcept {
+        auto this_index  = self.index();
+        auto other_index = other.index();
+        if (this_index != other_index) {
+            // Not the same alternative, so not equal
+            return false;
+        }
+        // Fold over the alternatives, and compare the two active ones:
+        const bool eq = static_cast<bool>(
+            (((this_index == Ns)
+              and self._storage.template get<Ns>() == other._storage.template get<Ns>())
+             or ...));
+        return eq;
+    }
+
+    template <typename... Ts, std::size_t... Ns>
+    static constexpr void
+    _impl_swap(variant<Ts...>& left, variant<Ts...>& right, std::index_sequence<Ns...>) {
+        // Our active index
+        auto left_index = left.index();
+        // The other's active index
+        auto right_index = right.index();
+        if (left_index != right_index) {
+            // We do not share the same alternative. Do an exchange-swap
+            variant tmp = NEO_MOVE(left);
+            left        = NEO_MOVE(right);
+            right       = NEO_MOVE(tmp);
+        } else {
+            // We share an alternative. Call the best available swapper for that alt:
+            static_cast<void>(((left_index == Ns
+                                and (neo::swap(left._storage.template get<Ns>(),
+                                               right._storage.template get<Ns>()),
+                                     true))
+                               or ...));
+        }
+    }
+
+    /**
+     * @brief Decay-copy construct a new value from another variant instance. It is assumed
+     * that no alternative is currently active.
+     *
+     * @param self This variant
+     * @param other The variant from which to copy/move.
+     */
+    template <typename Other, std::size_t... Ns>
+    static constexpr void _copy_anew_from(auto& self, Other&& other, std::index_sequence<Ns...>) {
+        const std::size_t other_index = other.index();
+        auto&             my_store    = self._storage;
+        auto&&            their_store = NEO_FWD(other)._storage;
+        my_store.nil.~unit();
+        static_cast<void>(((other_index == Ns
+                            and (static_cast<void>(my_store.template construct<Ns>(
+                                     NEO_FWD(their_store).template get<Ns>())),
+                                 true))
+                           or ...));
+        self._index = other._index;
+    }
+
+    /**
+     * @brief Decay-copy assign a new value from another variant instance. The currently
+     * held alternative is destroyed.
+     *
+     * @param other The variant from which to copy/move.
+     */
+    template <typename Other, std::size_t... Ns>
+    static constexpr void _copy_assign_from(auto& self, Other&& other, std::index_sequence<Ns...>) {
+        const std::size_t other_index = other.index();
+        const std::size_t my_index    = self.index();
+        if (my_index == other_index) {
+            // We both hold the same alternative. Copy-assign over the existing value
+            static_cast<void>(
+                ((other_index == Ns
+                  and (static_cast<void>(self._storage.template get<Ns>()
+                                         = NEO_FWD(other)._storage.template get<Ns>()),
+                       true))
+                 or ...));
+        } else {
+            // We contain different types. Use emplace(), which will destroy the current before
+            // copying the other
+            static_cast<void>((((other_index == Ns)
+                                and (static_cast<void>(self.template emplace<Ns>(
+                                         NEO_FWD(other)._storage.template get<Ns>())),
+                                     true))
+                               or ...));
+        }
+    }
+
+    template <std::size_t... Ns>
+    static constexpr void _do_destroy_current(auto& self, std::index_sequence<Ns...>) noexcept {
+        const auto current_index = self.index();
+        static_cast<void>((((current_index == Ns)
+                            and (static_cast<void>(self._storage.template destroy<Ns>()), true))
+                           or ...));
+    }
+
+    template <std::size_t N,
+              typename T,
+              typename Self,
+              typename Ref = add_lvalue_reference_t<T>,
+              typename OptionalRef
+              = conditional_t<void_type<T>, optional<void>, add_pointer_t<Ref>>>
+    constexpr static OptionalRef _do_try_get(Self& self) noexcept {
+        const std::size_t my_index = self.index();
+        if (N == my_index) {
+            if constexpr (void_type<T>) {
+                return OptionalRef{std::in_place};
+            } else {
+                auto& stor = self._storage;
+                auto& item = stor.template get<N>();
+                auto& ref  = static_cast<Ref>(item);
+                return NEO_ADDRESSOF(ref);
+            }
+        } else {
+            return OptionalRef{};
+        }
+    }
+
+    /**
+     * @brief Conversion-skipping equality operator.
+     *
+     * If there is a valid conversion target from the given operand, and the
+     * selected target is equality-comparable with the operand, then this
+     * operator defines the comparison without attempting to construct a new
+     * temporary `variant` from the altnerative.
+     *
+     * This operator== allows equality-comparing variants with values that are equality-comparable,
+     * even if the equality operator is not fully defined for other alternatives.
+     */
+    template <typename... Ts,
+              typename Other,
+              std::size_t N = _variant_detail::best_conversion_index_t<Other const&, Ts...>::value,
+              typename T    = meta::pack_at<N, Ts...>>
+        requires equality_comparable_with<Other const&, object_t<T>>
+    constexpr friend bool operator==(const variant<Ts...>& var, const Other& other) noexcept {
+        // Call out to a static member function. Older compilers do not consider friend functions
+        // to be within the scope of the enclosing class, thus the `friend variant_operators`
+        // declaration in variant<...> won't be respected here.
+        return _compare_eq<N, T>(var, other);
+    }
+
+    template <std::size_t N, typename T, typename Other, typename... Ts>
+    static constexpr bool _compare_eq(const variant<Ts...>& var, const Other& other) noexcept {
+        if (var.index() != N) {
+            // We do not hold the alternative under question.
+            return false;
+        }
+        // We are good to compare. DO NOT compare using try_get(): We want to
+        // compare unit as unit and reference_object as reference_object!
+        const object_t<T>& held = var._storage.template get<N>();
+        return held == other;
+    }
+
+    /**
+     * @brief Conversion-skipping comparison operator.
+     *
+     * If there is a valid conversion target from the given operand, and the
+     * selected target is three-way-comparable with the operand, then this
+     * operator defines the comparison without attempting to construct a new
+     * temporary `variant` from the altnerative.
+     *
+     * This operator<=> allows three-way-comparing variants with values that are comparable,
+     * even if an ordering is not fully defined for other alternatives.
+     */
+    template <typename... Ts,
+              typename Other,
+              std::size_t N = _variant_detail::best_conversion_index_t<Other const&, Ts...>::value,
+              typename T    = meta::pack_at<N, Ts...>>
+        requires totally_ordered_with<object_t<T>, Other const&>
+    constexpr friend synth_three_way_result_t<object_t<T>, Other const&>
+    operator<=>(const variant<Ts...>& var, const Other& other) noexcept {
+        // See above operator== for why this is a separate function
+        return _compare_3way<N, T>(var, other);
+    }
+
+    template <std::size_t N, typename T, typename Other, typename... Ts>
+    constexpr static synth_three_way_result_t<object_t<T>, Other>
+    _compare_3way(const variant<Ts...>& var, const Other& other) noexcept {
+        if (var.index() != N) {
+            // Not the same alternative, so order based on the expected alternative index:
+            return var.index() <=> N;
+        }
+        // We are good to compare. DO NOT compare using try_get(): We want to
+        // compare unit as unit and reference_object as reference_object!
+        const object_t<T>& held = var._storage.template get<N>();
+        return synth_three_way(held, other);
+    }
+};
+
+}  // namespace _variant_detail
+
+}  // namespace neo
diff --git a/src/neo/variant.test.cpp b/src/neo/variant.test.cpp
new file mode 100644
index 0000000..121ea06
--- /dev/null
+++ b/src/neo/variant.test.cpp
@@ -0,0 +1,453 @@
+#include <neo/get.hpp>
+#include <neo/testing.hpp>
+#include <neo/variant.hpp>
+
+#include <compare>
+#include <memory>
+#include <string>
+
+#include <catch2/catch.hpp>
+
+using namespace std::literals;
+using neo::variant;
+
+static_assert(neo::default_initializable<variant<int>>);
+static_assert(neo::trivially_destructible<variant<int>>);
+static_assert(neo::trivially_copyable<variant<int>>);
+static_assert(neo::trivially_movable<variant<int>>);
+
+static_assert(neo::regular<variant<int>>);
+static_assert(neo::regular<variant<int, int>>);
+
+static_assert(neo::default_initializable<variant<std::string>>);
+static_assert(not neo::trivially_destructible<variant<std::string>>);
+static_assert(neo::copyable<variant<std::string>>);
+static_assert(not neo::trivially_copyable<variant<std::string>>);
+static_assert(neo::movable<variant<std::string>>);
+static_assert(not neo::trivially_movable<variant<std::string>>);
+
+struct not_trivially_copyable {
+    not_trivially_copyable(const not_trivially_copyable&) {}
+    not_trivially_copyable(not_trivially_copyable&&) = default;
+};
+
+static_assert(neo::trivially_destructible<variant<not_trivially_copyable>>);
+static_assert(not neo::trivially_copy_constructible<not_trivially_copyable>);
+static_assert(neo::copy_constructible<variant<not_trivially_copyable>>);
+static_assert(neo::move_constructible<variant<not_trivially_copyable>>);
+static_assert(neo::trivially_move_constructible<variant<not_trivially_copyable>>);
+static_assert(neo::trivially_move_constructible<neo::object_box<not_trivially_copyable>>);
+static_assert(
+    neo::trivially_move_constructible<variant<not_trivially_copyable, not_trivially_copyable>>);
+static_assert(neo::move_constructible<variant<not_trivially_copyable, not_trivially_copyable>>);
+static_assert(not neo::trivially_movable<variant<not_trivially_copyable>>);
+
+static_assert(not neo::default_initializable<variant<int&>>);
+static_assert(neo::trivially_destructible<variant<int&>>);
+static_assert(neo::trivially_copyable<variant<int&>>);
+static_assert(neo::trivially_movable<variant<int&>>);
+
+static_assert(not neo::default_initializable<variant<const int&>>);
+static_assert(neo::trivially_destructible<variant<const int&>>);
+static_assert(neo::trivially_copyable<variant<const int&>>);
+static_assert(neo::trivially_movable<variant<const int&>>);
+
+static_assert(neo::default_initializable<variant<void>>);
+static_assert(neo::trivially_destructible<variant<void>>);
+static_assert(neo::trivially_copyable<variant<void>>);
+static_assert(neo::trivially_movable<variant<void>>);
+
+static_assert(neo::default_initializable<variant<const void>>);
+static_assert(neo::trivially_destructible<variant<const void>>);
+static_assert(neo::trivially_copyable<variant<const void>>);
+static_assert(neo::trivially_movable<variant<const void>>);
+
+static_assert(neo::equality_comparable<variant<int>>);
+static_assert(neo::totally_ordered<variant<int>>);
+static_assert(neo::totally_ordered<variant<int, double>>);
+
+neo::testing::cx_test_case DefaultConstruction = [](auto check) consteval {
+    variant<int> i;
+    check(i.index() == 0);
+    auto o = i.try_get<0>();
+    check(!!o);
+    check(*o == 0);
+};
+
+neo::testing::cx_test_case VoidDefault = [](auto check) consteval {
+    variant<void> v;
+    check(v.index() == 0);
+    std::same_as<neo::optional<void>> auto o = v.try_get<0>();
+    check(o.has_value());
+    (void)o.value();
+};
+
+struct not_constexpr {
+    not_constexpr() {}
+};
+
+neo::testing::cx_test_case ConstexprWithNonLiteralAlternatives = [](auto check) consteval {
+    // XXX: Clang is missing CWG 2096: See llvm-project#40183
+    variant<int, not_constexpr> v;
+    check(v.index() == 0);
+};
+
+neo::testing::cx_test_case AmbiguousAlternativeConstruction = [](auto check) consteval {
+    variant<int, int> v;
+    check(v.index() == 0);
+    v.emplace<1>(31);
+    check(v.index() == 1);
+    check(*v.try_get<1>() == 31);
+    static_assert(neo::assignable_from<variant<int, std::string>&, int>);
+    // Assignment would be ambiguous:
+    static_assert(not neo::assignable_from<variant<int, int>&, int>);
+
+    variant<int, int&> var_with_ref;
+    // Choses the first altnerative, since the `int&` would require binding an rvalue
+    // to an lvalue-reference:
+    var_with_ref = 31;
+    check(var_with_ref.index() == 0);
+    int tmp = 42;
+    // Ambiguous with an lvalue reference
+    static_assert(not neo::assignable_from<variant<int, int&>, int&>);
+    const int& cref = tmp;
+    // Choses first alternative, since the `int const&` cannot convert to `int&`
+    var_with_ref = cref;
+    check(var_with_ref.index() == 0);
+};
+
+neo::testing::cx_test_case ConstructFromIndex = [](auto check) consteval {
+    {
+        variant<int> i{std::in_place_index<0>, 21};
+        check(i.index() == 0);
+        check(*i.try_get<0>() == 21);
+    }
+    {
+        variant<void> with_void{std::in_place_index<0>};
+        check(with_void.index() == 0);
+        check(!!with_void.try_get<0>());
+    }
+    {
+        variant<int, char> multiple{std::in_place_index<1>, 'h'};
+        check(*multiple.try_get<1>() == 'h');
+    }
+    {
+        int           i = 42;
+        variant<int&> with_ref{std::in_place_index<0>, i};
+        check(*with_ref.try_get<0>() == 42);
+        *with_ref.try_get<0>() = 21;
+        check(i == 21);
+
+        int other = 71;
+        with_ref  = other;
+        check(i == 21);  // Did not modify i
+        check(*with_ref.try_get<0>() == 71);
+    }
+};
+
+template <int N>
+struct item {
+    constexpr ~item() {}
+};
+
+neo::testing::cx_test_case HugeVariants = [](auto) consteval {
+    neo::variant<int> just_int [[maybe_unused]];
+    neo::variant<item<1>,
+                 item<2>,
+                 item<3>,
+                 item<4>,
+                 item<5>,
+                 item<6>,
+                 item<7>,
+                 item<8>,
+                 item<9>,
+                 item<10>>
+        t1 [[maybe_unused]];
+
+    neo::variant<item<1>, item<2>, item<3>, item<4>, item<5>, item<6>, item<7>, item<8>> t2
+        [[maybe_unused]];
+
+    neo::variant<item<0>,
+                 item<1>,
+                 item<2>,
+                 item<3>,
+                 item<4>,
+                 item<5>,
+                 item<6>,
+                 item<7>,
+                 item<8>,
+                 item<9>,
+                 item<10>,
+                 item<11>,
+                 item<12>,
+                 item<13>,
+                 item<14>,
+                 item<15>,
+                 item<16>,
+                 item<17>,
+                 item<18>,
+                 item<19>,
+                 item<20>,
+                 item<21>,
+                 item<22>,
+                 item<23>,
+                 item<24>,
+                 item<25>,
+                 item<26>,
+                 item<27>,
+                 item<28>,
+                 item<29>,
+                 item<30>,
+                 item<31>,
+                 item<32>,
+                 item<33>,
+                 item<34>,
+                 item<35>,
+                 item<36>,
+                 item<37>,
+                 item<38>,
+                 item<39>,
+                 item<40>,
+                 item<41>,
+                 item<42>,
+                 item<43>,
+                 item<44>,
+                 item<45>,
+                 item<46>,
+                 item<47>,
+                 item<48>,
+                 item<49>,
+                 item<50>,
+                 item<51>,
+                 item<52>,
+                 item<53>,
+                 item<54>,
+                 item<55>,
+                 item<56>,
+                 item<57>,
+                 item<58>,
+                 item<59>,
+                 item<60>,
+                 item<61>,
+                 item<62>,
+                 item<63>,
+                 item<64>,
+                 item<65>,
+                 item<66>,
+                 item<67>,
+                 item<68>,
+                 item<69>,
+                 item<70>,
+                 item<71>,
+                 item<72>,
+                 item<73>,
+                 item<74>,
+                 item<75>,
+                 item<76>,
+                 item<77>,
+                 item<78>,
+                 item<79>,
+                 item<80>,
+                 item<81>>
+              t3;
+    item<24>* _24 [[maybe_unused]] = t3.try_get<24>();
+    item<25>* _25 [[maybe_unused]] = t3.try_get<25>();
+    item<33>* _33 [[maybe_unused]] = t3.try_get<33>();
+    item<66>* _66 [[maybe_unused]] = t3.try_get<66>();
+    item<78>* _78 [[maybe_unused]] = t3.try_get<78>();
+    item<81>* _81 [[maybe_unused]] = t3.try_get<81>();
+
+    item<6>* six [[maybe_unused]]   = t3.try_get<6>();
+    item<8>* eight [[maybe_unused]] = t3.try_get<8>();
+};
+
+struct composite {
+    std::vector<int> v = {1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
+};
+
+TEST_CASE("Converting construct from a value") {
+    neo::variant<std::string> s = "hello";
+    CHECK(s.index() == 0);
+    CHECK(s == "hello");
+    CHECK(neo::get_as<std::string>(s) == "hello");
+}
+
+struct tracks_assignment {
+    bool was_assigned_to = false;
+    constexpr tracks_assignment() noexcept {}
+
+    tracks_assignment(const tracks_assignment&) = default;
+
+    constexpr tracks_assignment& operator=(tracks_assignment) noexcept {
+        was_assigned_to = true;
+        return *this;
+    }
+};
+
+neo::testing::cx_test_case AssignThruBehavior = [](auto check) consteval {
+    variant<int, tracks_assignment> v1 = 31;
+    check(v1 == 31);
+    variant<int, tracks_assignment> v2 = tracks_assignment{};
+    // Do the first assignment, which changes the alt
+    v1 = v2;
+    check(v1.try_get<1>()->was_assigned_to == false);
+    // Second assignment will assign-through
+    v1 = v2;
+    check(v1.try_get<1>()->was_assigned_to == true);
+
+    int                    i    = 41;
+    int                    i2   = 71;
+    double                 d    = 3.14;
+    variant<int&, double&> refs = d;
+    check(refs.index() == 1);
+    refs = i;
+    check(refs.index() == 0);
+    check(&*refs.try_get<0>() == &i);
+    // Subsequent will use the assign-through logic, but it will only rebind the reference.
+    // IT MUST NOT assign-through on reference itself.
+    refs = i2;
+    check(refs.index() == 0);
+    check(&*refs.try_get<0>() == &i2);
+    // Check that i and i2 are unchanged:
+    check(i == 41);
+    check(i2 == 71);
+
+    variant<int, void> with_void;
+    check(with_void.index() == 0);
+    variant<int, void> as_void{std::in_place_index<1>};
+    check(as_void.index() == 1);
+    with_void = as_void;  // Switch from `int` to `void`
+    check(with_void.index() == 1);
+    with_void = 31;
+    check(with_void.index() == 0);
+    with_void = neo::unit{};  // Rebinds to `void`
+    check(with_void.index() == 1);
+};
+
+neo::testing::cx_test_case VariantOrdering = [](auto check) consteval {
+    variant<int, double, char> v1, v2, v3;
+    check(v1 == v2);
+    v1 = 900;
+    check(v1 < 3.14);  // int is less than a double literal
+    check(v1 > v2);
+    check(v1 > v3);
+    v2 = 3.14;       // Becomes `double`
+    check(v2 > v1);  // The double alternative is "greater than" the int altnerative
+    v3 = 'a';
+    check(v3 > v2);
+    check(v3 > v1);
+};
+
+TEST_CASE("Get Nth from neo::variant<>") {
+    STATIC_REQUIRE(neo::can_get_nth<neo::variant<int>, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<neo::variant<int>&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<neo::variant<int> const&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<neo::variant<int>&&, 0>);
+    STATIC_REQUIRE(neo::can_get_nth<neo::variant<int> const&&, 0>);
+    STATIC_REQUIRE(not neo::can_get_nth<neo::variant<int>, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<neo::variant<int>&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<neo::variant<int> const&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<neo::variant<int>&&, 1>);
+    STATIC_REQUIRE(not neo::can_get_nth<neo::variant<int> const&&, 1>);
+}
+
+TEST_CASE("Get T from neo::variant<>") {
+    STATIC_REQUIRE(neo::can_get_as<neo::variant<int, double>, int>);
+    STATIC_REQUIRE(neo::can_get_as<neo::variant<int, double>&, int>);
+    STATIC_REQUIRE(neo::can_get_as<neo::variant<int, double> const&, int>);
+    STATIC_REQUIRE(neo::can_get_as<neo::variant<int, double>&&, int>);
+    STATIC_REQUIRE(neo::can_get_as<neo::variant<int, double> const&&, int>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double>, char>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double>&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double> const&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double>&&, char>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double> const&&, char>);
+
+    // The type T must be exactly an alternative, no cvr allowed:
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double>, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double>&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double> const&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double>&&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, double> const&&, int&>);
+
+    // The type T must occur exactly once
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, int>, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, int>&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, int> const&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, int>&&, int&>);
+    STATIC_REQUIRE(not neo::can_get_as<neo::variant<int, int> const&&, int&>);
+
+    // Getting from a variant applies the cvref qualifiers:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int>, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int>&, int>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int> const&, int>, const int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int>&&, int>, int&&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int> const&&, int>, const int&&>);
+
+    // Reference collapsing:
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int&>, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int&>&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int&> const&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int&>&&, int&>, int&>);
+    STATIC_REQUIRE(std::same_as<neo::get_as_t<neo::variant<int&> const&&, int&>, int&>);
+}
+
+struct not_default_constructible {
+    not_default_constructible(int) {}
+};
+
+TEST_CASE("Not-default-constructible") {
+    STATIC_REQUIRE_FALSE(neo::default_initializable<neo::variant<not_default_constructible>>);
+    // We are default-constructible only if the first alt is default constructible
+    STATIC_REQUIRE(
+        neo::default_initializable<neo::variant<std::string, not_default_constructible>>);
+    STATIC_REQUIRE_FALSE(
+        neo::default_initializable<neo::variant<not_default_constructible, std::string>>);
+
+    neo::variant<not_default_constructible> ord = not_default_constructible{42};
+}
+
+template <typename T>
+bool _static_checks() {
+#define CHECK_SAME(Trait)                                                                          \
+    static_assert(neo::Trait<T> == neo::Trait<neo::variant<T>>);                                   \
+    static_assert(neo::Trait<T> == neo::Trait<neo::variant<T, T>>)
+    CHECK_SAME(default_initializable);
+    CHECK_SAME(copy_constructible);
+    CHECK_SAME(move_constructible);
+    CHECK_SAME(trivially_copy_constructible);
+    CHECK_SAME(trivially_move_constructible);
+    CHECK_SAME(trivially_copy_assignable);
+    CHECK_SAME(trivially_move_assignable);
+    CHECK_SAME(trivially_copyable);
+    CHECK_SAME(trivially_movable);
+    CHECK_SAME(trivially_destructible);
+    return true;
+}
+
+TEST_CASE("Static checks") {
+    _static_checks<int>();
+    _static_checks<double>();
+    _static_checks<std::string>();
+    _static_checks<std::unique_ptr<int>>();
+}
+
+TEST_CASE("Triviallity") {
+    neo::variant<void> v [[maybe_unused]];
+    STATIC_REQUIRE(neo::trivially_destructible<neo::variant<void>>);
+    STATIC_REQUIRE(neo::trivially_copyable<neo::variant<void>>);
+    STATIC_REQUIRE(neo::trivially_copyable<neo::variant<int>>);
+    STATIC_REQUIRE(neo::trivially_movable<neo::variant<int>>);
+    STATIC_REQUIRE(neo::trivially_copy_constructible<neo::variant<int>>);
+    STATIC_REQUIRE(neo::trivially_move_constructible<neo::variant<int>>);
+    STATIC_REQUIRE(neo::trivially_copy_assignable<neo::variant<int>>);
+    STATIC_REQUIRE(neo::trivially_move_assignable<neo::variant<int>>);
+
+    STATIC_REQUIRE(not neo::trivially_copyable<neo::variant<std::string>>);
+    STATIC_REQUIRE(not neo::trivially_copyable<neo::variant<std::string, void>>);
+    STATIC_REQUIRE(not neo::trivially_movable<neo::variant<std::string>>);
+    STATIC_REQUIRE(not neo::trivially_copy_constructible<neo::variant<std::string>>);
+    STATIC_REQUIRE(not neo::trivially_move_constructible<neo::variant<std::string>>);
+    STATIC_REQUIRE(not neo::trivially_copy_assignable<neo::variant<std::string>>);
+    STATIC_REQUIRE(not neo::trivially_move_assignable<neo::variant<std::string>>);
+}
diff --git a/src/neo/variant_get.cpp b/src/neo/variant_get.cpp
deleted file mode 100644
index f074d53..0000000
--- a/src/neo/variant_get.cpp
+++ /dev/null
@@ -1,5 +0,0 @@
-#include "./variant_get.hpp"
-
-#include <variant>
-
-void neo::var_detail::throw_bad_variant_access() { throw std::bad_variant_access(); }
diff --git a/src/neo/variant_get.hpp b/src/neo/variant_get.hpp
deleted file mode 100644
index 665761a..0000000
--- a/src/neo/variant_get.hpp
+++ /dev/null
@@ -1,157 +0,0 @@
-#pragma once
-
-#include "./addressof.hpp"
-#include "./like.hpp"
-#include "./overload.hpp"
-#include "./platform.hpp"
-#include "./tl.hpp"
-
-#include <concepts>
-
-namespace neo {
-
-namespace var_detail {
-
-[[noreturn]] void throw_bad_variant_access();
-
-template <typename>
-void try_get(...) = delete;
-
-template <typename>
-void get_if(...) = delete;
-
-template <typename Result, typename Alt>
-concept try_get_result = requires(Result res, void (*fn)(Alt& ref)) {
-    { res ? 0 : 0 } noexcept;
-    fn(*res);
-};
-
-template <typename Variant, typename Alt>
-concept has_adl_try_get = requires(Variant&& var) {
-    { try_get<Alt>(var) } -> try_get_result<forward_like_t<Variant, Alt>>;
-};
-
-template <typename Variant, typename Alt>
-concept has_member_try_get = requires(Variant&& var) {
-    { var.template try_get<Alt>() } -> try_get_result<forward_like_t<Variant, Alt>>;
-};
-
-template <typename Variant, typename Alt>
-concept has_adl_get_if = requires(Variant&& var) {
-    { get_if<Alt>(neo::addressof(var)) } -> try_get_result<forward_like_t<Variant, Alt>>;
-};
-
-#if NEO_COMPILER(GNU)
-template <typename Alt>
-constexpr inline auto try_get_impl = neo::ordered_overload{
-    [](has_member_try_get<Alt> auto&& var) noexcept { return var.template try_get<Alt>(); },
-    [](has_adl_try_get<Alt> auto&& var) noexcept { return try_get<Alt>(var); },
-    [](has_adl_get_if<Alt> auto&& var) noexcept { return get_if<Alt>(neo::addressof(var)); },
-};
-#else
-template <typename Alt>
-constexpr inline auto try_get_impl = neo::ordered_overload{
-    [] NEO_CTL(_1.template try_get<Alt>()),
-    [] NEO_CTL(try_get<Alt>(_1)),
-    [] NEO_CTL(get_if<Alt>(neo::addressof(_1))),
-};
-#endif
-
-template <typename Variant, typename Alt>
-concept has_try_get =                    //
-    has_adl_try_get<Variant, Alt>        //
-    or has_member_try_get<Variant, Alt>  //
-    or has_adl_get_if<Variant, Alt>;
-
-template <typename Var, typename Alt>
-constexpr bool std_variant_mask = true;
-
-template <typename T>
-struct inherit_from : T {};
-
-template <template <class...> class VariantTmpl, typename... Types, typename Alt>
-    requires weak_same_as<typename inherit_from<VariantTmpl<Types...>>::variant,
-                          VariantTmpl<Types...>>
-constexpr bool std_variant_mask<VariantTmpl<Types...>, Alt> = (weak_same_as<Types, Alt> || ...);
-
-template <typename Variant, typename Alt>
-concept supports_alternative =    //
-    has_try_get<Variant, Alt> &&  //
-    std_variant_mask<remove_cvref_t<Variant>, Alt>;
-
-}  // namespace var_detail
-
-/**
- * @brief Check that the given sum-type-like 'Variant' supports 'Alt' as one of its alternatives
- *
- * @tparam Variant A variant-like type that can hold one of multiple types
- * @tparam Alt A possible type to assign-to/obtain-from Variant
- */
-// clang-format off
-template <typename Variant, typename Alt>
-concept supports_alternative
-      = var_detail::supports_alternative<Variant, Alt>
-    and assignable_from<remove_cvref_t<Variant>&, Alt&&>
-    and convertible_to<Alt&&, remove_cvref_t<Variant>>;
-// clang-format on
-
-template <typename Alternative>
-struct try_get_fn {
-    template <supports_alternative<Alternative> Var>
-    constexpr auto operator()(Var&& var) const
-        NEO_RETURNS(var_detail::try_get_impl<Alternative>(NEO_FWD(var)));
-};
-
-/**
- * @brief Try to obtain a pointer to a given alternative from a variant-like type
- *
- * @returns nullptr if the variant-like object is not currently holding the given alternative type,
- * otherwise returns a pointer to the held alternative.
- */
-template <typename Alt>
-constexpr inline auto try_get = try_get_fn<Alt>{};
-
-template <typename Alternative>
-struct holds_alternative_fn {
-    constexpr bool operator()(supports_alternative<Alternative> auto const& var) const noexcept {
-        return static_cast<bool>(try_get<Alternative>(var));
-    }
-};
-
-/**
- * @brief Determine whether a variant-like type is currently holding the given alternative type.
- */
-template <typename Alt>
-constexpr inline auto holds_alternative = holds_alternative_fn<Alt>{};
-
-template <typename Alternative>
-struct get_fn {
-    template <supports_alternative<Alternative> Variant>
-    constexpr decltype(auto) operator()(Variant&& var) const {
-        auto maybe = try_get<Alternative>(var);
-        if (not static_cast<bool>(maybe)) {
-            var_detail::throw_bad_variant_access();
-        }
-        if constexpr (reference_type<Alternative>) {
-            return static_cast<Alternative>(*maybe);
-        } else {
-            if constexpr (rvalue_reference_type<Variant&&>) {
-                return NEO_MOVE(*maybe);
-            } else {
-                return *maybe;
-            }
-        }
-    }
-};
-
-/**
- * @brief Obtain the given alternative of a variant-like if that alternative is active.
- *
- * @tparam Alt The type to pull from a variant-like type
- * @throws std::bad_variant_access If attempting to pull a value from a variant that does not have
- * that type active.
- */
-template <typename Alt>
-constexpr inline auto get = get_fn<Alt>{};
-
-}  // namespace neo
diff --git a/src/neo/variant_get.test.cpp b/src/neo/variant_get.test.cpp
deleted file mode 100644
index f35ce68..0000000
--- a/src/neo/variant_get.test.cpp
+++ /dev/null
@@ -1,24 +0,0 @@
-#include "./variant_get.hpp"
-
-#include "./tag.hpp"
-
-#include <catch2/catch.hpp>
-
-#include <variant>
-
-static_assert(neo::supports_alternative<std::variant<int>, int>);
-static_assert(neo::supports_alternative<std::variant<int>&, int>);
-static_assert(neo::supports_alternative<std::variant<int> const&, int>);
-static_assert(neo::supports_alternative<std::variant<int>&&, int>);
-static_assert(neo::supports_alternative<std::variant<int, std::string>, int>);
-static_assert(neo::supports_alternative<std::variant<int, std::string>&, int>);
-static_assert(neo::supports_alternative<std::variant<int, std::string> const&, int>);
-static_assert(neo::supports_alternative<std::variant<int, std::string>&&, int>);
-static_assert(!neo::supports_alternative<std::variant<int>, std::string>);
-
-static_assert(not neo::supports_alternative<int, double>);
-
-TEST_CASE("Get an alternative") {
-    std::variant<int, std::string> s = 12;
-    CHECK(neo::holds_alternative<int>(s));
-}
diff --git a/tools/msvc.jsonc b/tools/msvc.jsonc
index 241bf98..baa4c2d 100644
--- a/tools/msvc.jsonc
+++ b/tools/msvc.jsonc
@@ -3,7 +3,8 @@
     "flags": [
         "/std:c++latest",
         "/Zc:preprocessor",
-        "/utf-8"
+        "/utf-8",
+        "/diagnostics:caret"
     ],
     "warning_flags": [
         "/WX",