diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 1ce7b67..ec9c62e 100644 --- a/.github/workflows/ci.yml +++ b/.github/workflows/ci.yml @@ -2,39 +2,70 @@ name: Build and Test on: [push, pull_request] jobs: + build-gcc13: + name: Build for GCC 13.2 + runs-on: ubuntu-latest + steps: + - name: Checkout + uses: actions/checkout@v4 + - name: Build and Test + run: bash tools/earthly.sh +build-gcc --gcc_version=13.2 + build-gcc12: - name: Build for GCC 12.2 + name: Build for GCC 12.3 runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Build and Test - run: bash tools/earthly.sh +build-gcc-12.2 + run: bash tools/earthly.sh +build-gcc --gcc_version=12.3 build-gcc11: - name: Build for GCC 11.2 + name: Build for GCC 11.4 runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Build and Test - run: bash tools/earthly.sh +build-gcc-11.2 + run: bash tools/earthly.sh +build-gcc --gcc_version=11.4 build-gcc10: name: Build for GCC 10.3 runs-on: ubuntu-latest steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 - 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 [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@v2 + uses: actions/checkout@v4 - name: Build and Test run: tools/build-vs2019e.bat -Toolchain tools/msvc.jsonc @@ -43,6 +74,6 @@ jobs: runs-on: windows-2022 steps: - name: Checkout - uses: actions/checkout@v2 + uses: actions/checkout@v4 - name: Build and Test run: tools/build-vs2022e.bat -Toolchain tools/msvc.jsonc diff --git a/.gitignore b/.gitignore index bcca10f..411d969 100644 --- a/.gitignore +++ b/.gitignore @@ -1,2 +1,3 @@ _build/ -.vscode/ \ No newline at end of file +.vscode/ +.cache/ \ No newline at end of file diff --git a/Earthfile b/Earthfile index 3fbe224..4ffaaf7 100644 --- a/Earthfile +++ b/Earthfile @@ -1,4 +1,4 @@ -VERSION 0.6 +VERSION --pass-args --arg-scope-and-set 0.7 bpt-linux: FROM alpine:3.16 @@ -10,90 +10,117 @@ bpt-linux: BUILD: COMMAND + ARG --required toolchain COPY --dir src/ tools/ conf/ bpt.yaml /s COPY +bpt-linux/bpt /usr/local/bin/bpt WORKDIR /s - RUN --mount=type=cache,target=/root/.ccache \ - bpt build --toolchain=/toolchain.yaml --tweaks-dir=conf + RUN --mount=type=cache,target=/root/.ccache,sharing=shared \ + bpt build --toolchain=$toolchain --tweaks-dir=conf -PREP_GCC: +PREP_GCC_TOOLCHAIN: COMMAND - RUN apk add gcc g++ ARG runtime_debug=true ARG cxx_flags RUN jq -n \ - --arg cxx_flags "$cxx_flags -fconcepts-diagnostics-depth=10" \ - --argjson runtime_debug "$runtime_debug" \ - '{ \ - compiler_id: "gnu", \ - cxx_version: "c++20", \ - cxx_flags: $cxx_flags, \ - debug: true, \ - runtime: {debug: $runtime_debug}, \ - warning_flags: ["-Werror", "-Wsign-compare"], \ - compiler_launcher: "ccache", \ - }' \ - | tee /toolchain.yaml + --arg cxx_flags "$cxx_flags -fconcepts-diagnostics-depth=10" \ + --argjson runtime_debug "$runtime_debug" \ + '{ \ + compiler_id: "gnu", \ + cxx_version: "c++20", \ + cxx_flags: $cxx_flags, \ + debug: true, \ + runtime: {debug: $runtime_debug}, \ + warning_flags: ["-Werror", "-Wsign-compare"], \ + link_flags: ["-fuse-ld=lld"], \ + compiler_launcher: "ccache", \ + }' > /toolchain.yaml && \ + echo "Using the following toolchain:" && \ + cat /toolchain.yaml -PREP_CLANG: +ALPINE_PREP_GCC: + COMMAND + RUN apk add gcc g++ + DO --pass-args +PREP_GCC_TOOLCHAIN + +ALPINE_PREP_CLANG: COMMAND ARG apk_install=true RUN ! "$apk_install" || apk add clang g++ + DO --pass-args +PREP_CLANG_TOOLCHAIN + +PREP_CLANG_TOOLCHAIN: + COMMAND ARG runtime_debug=true ARG cxx_flags RUN jq -n \ - --arg cxx_flags "$cxx_flags" \ - --argjson runtime_debug "$runtime_debug" \ - '{ \ - compiler_id: "clang", \ - cxx_version: "c++2b", \ - cxx_flags: $cxx_flags, \ - debug: true, \ - runtime: {debug: $runtime_debug}, \ - warning_flags: ["-Werror", "-Wsign-compare"], \ - compiler_launcher: "ccache", \ - }' \ - | tee /toolchain.yaml + --arg cxx_flags "$cxx_flags" \ + --argjson runtime_debug "$runtime_debug" \ + '{ \ + compiler_id: "clang", \ + cxx_version: "c++2b", \ + cxx_flags: $cxx_flags, \ + debug: true, \ + runtime: {debug: $runtime_debug}, \ + warning_flags: ["-Werror", "-Wsign-compare"], \ + link_flags: ["-fuse-ld=lld"], \ + compiler_launcher: "ccache", \ + }' > /toolchain.yaml && \ + echo "Using the following toolchain:" && \ + cat /toolchain.yaml ALPINE_BUILD: COMMAND ARG --required version FROM alpine:$version - RUN apk add jq musl-dev ccache + RUN apk add jq musl-dev ccache lld ARG --required prep ARG cxx_flags ARG runtime_debug=true - DO +$prep --cxx_flags=$cxx_flags --runtime_debug=$runtime_debug - DO +BUILD - -build-gcc-12.2: - DO +ALPINE_BUILD --version=3.17 --prep=PREP_GCC + DO --pass-args +$prep + DO +BUILD --toolchain=/toolchain.yaml -build-gcc-11.2: - DO +ALPINE_BUILD --version=3.16 --prep=PREP_GCC +build-gcc: + ARG --required gcc_version + FROM docker.io/library/gcc:$gcc_version + RUN apt-get update && apt-get install -y ccache lld jq + DO --pass-args +PREP_GCC_TOOLCHAIN + DO --pass-args +BUILD --toolchain=/toolchain.yaml build-gcc-10.3: - DO +ALPINE_BUILD --version=3.15 --prep=PREP_GCC --cxx_flags="-fcoroutines" --runtime_debug=false + 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 build-clang-15: - DO +ALPINE_BUILD --version=3.17 --prep=PREP_CLANG + # XXX: Currently broken! + DO +ALPINE_BUILD --version=3.17 --prep=ALPINE_PREP_CLANG -build-clang-latest: +build-clang-snapshot: # Use Ubuntu for this one, since LLVM ships binaries in their APT repo FROM ubuntu:22.04 RUN apt-get update && \ apt-get -y install curl software-properties-common gpg jq ccache + LET ubuntu_codename=$(cat /etc/os-release | grep UBUNTU_CODENAME | sed 's/.*=//') RUN curl -Ls https://apt.llvm.org/llvm-snapshot.gpg.key | apt-key add - && \ - add-apt-repository "deb http://apt.llvm.org/jammy/ llvm-toolchain-jammy main" - RUN apt-get update && apt-get -y install clang-16 + add-apt-repository "deb http://apt.llvm.org/$ubuntu_codename/ llvm-toolchain-$ubuntu_codename main" + LET snapshot_version=18 + RUN apt-get update && apt-get -y install clang-$snapshot_version lld-$snapshot_version # Link the names so bpt can find them without more toolchain tweaks - RUN ln -s /usr/bin/clang-16 /usr/local/bin/clang && \ - ln -s /usr/bin/clang++-16 /usr/local/bin/clang++ - DO +PREP_CLANG --apk_install=false - DO +BUILD + RUN ln -s /usr/bin/clang-$snapshot_version /usr/local/bin/clang && \ + ln -s /usr/bin/clang++-$snapshot_version /usr/local/bin/clang++ && \ + ln -s /usr/bin/ld.lld-$snapshot_version /usr/local/bin/ld.lld + DO --pass-args +PREP_CLANG_TOOLCHAIN + DO +BUILD --toolchain=/toolchain.yaml -build-gcc-multi: +build-all: # NOTE: This could use a LOT of CPU! There's no task coordination here! - BUILD +build-gcc-12.2 - BUILD +build-gcc-11.2 BUILD +build-gcc-10.3 + BUILD +build-gcc \ + --gcc_version=13.2 \ + --gcc_version=12.3 \ + --gcc_version=11.4 + BUILD +build-clang-16 diff --git a/bpt.yaml b/bpt.yaml index 2814327..ebafcb7 100644 --- a/bpt.yaml +++ b/bpt.yaml @@ -1,5 +1,5 @@ name: neo-fun -version: 0.13.1 +version: 0.14.0 test-dependencies: - catch2@2.13.7 using main readme: README.md 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 #endif @@ -20,7 +14,7 @@ namespace neo { */ template 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 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/archetypes.hpp b/src/neo/archetypes.hpp index 9499dd4..5d32420 100644 --- a/src/neo/archetypes.hpp +++ b/src/neo/archetypes.hpp @@ -22,10 +22,53 @@ struct unconstructible { unconstructible() = delete; }; +struct deleted_copy_constructor { + deleted_copy_constructor(const deleted_copy_constructor&) = delete; + deleted_copy_constructor(deleted_copy_constructor&&) = default; + + deleted_copy_constructor& operator=(const deleted_copy_constructor&) = default; + deleted_copy_constructor& operator=(deleted_copy_constructor&&) = default; +}; + +struct deleted_move_constructor { + deleted_move_constructor(const deleted_move_constructor&) = default; + deleted_move_constructor(deleted_move_constructor&&) = delete; + + deleted_move_constructor& operator=(const deleted_move_constructor&) = default; + deleted_move_constructor& operator=(deleted_move_constructor&&) = default; +}; + +struct deleted_copy_assignment { + deleted_copy_assignment(const deleted_copy_assignment&) = default; + deleted_copy_assignment(deleted_copy_assignment&&) = default; + + deleted_copy_assignment& operator=(const deleted_copy_assignment&) = delete; + deleted_copy_assignment& operator=(deleted_copy_assignment&&) = default; +}; + +struct deleted_move_assignment { + deleted_move_assignment(const deleted_move_assignment&) = default; + deleted_move_assignment(deleted_move_assignment&&) = default; + + deleted_move_assignment& operator=(const deleted_move_assignment&) = default; + deleted_move_assignment& operator=(deleted_move_assignment&&) = delete; +}; + +struct deleted_copy_move { + deleted_copy_constructor _1; + deleted_move_constructor _2; +}; + +struct deleted_assignment { + deleted_copy_assignment _1; + deleted_move_assignment _2; +}; + /** * @brief Mixin to make a type non-movable (immobile) */ struct immovable { + immovable() = default; immovable(immovable&&) = delete; }; @@ -33,6 +76,7 @@ struct immovable { * @brief Mixin to make a type move-only (non-copyable) */ struct uncopyable { + uncopyable() = default; uncopyable(uncopyable&&); uncopyable& operator=(uncopyable&&); }; @@ -170,6 +214,117 @@ struct predicate : pathological { bool operator()(Args&&...); }; +struct trivially_default_constructible { + // XXX: https://cplusplus.github.io/LWG/issue2116 + // ~trivially_default_constructible() {} + uncopyable _2; + immovable _3; +}; + +struct nontrivial_default_constructor { + nontrivial_default_constructor(); +}; + +struct nontrivial_destructor { + ~nontrivial_destructor(); +}; + +struct nontrivial_copy_constructor { + nontrivial_copy_constructor(const nontrivial_copy_constructor&); + nontrivial_copy_constructor& operator=(const nontrivial_copy_constructor&) & = default; +}; + +struct nontrivial_move_constructor { + nontrivial_move_constructor(nontrivial_move_constructor&&); + nontrivial_move_constructor& operator=(nontrivial_move_constructor&&) & = default; +}; + +struct nontrivial_copy_assignment { + nontrivial_copy_assignment(const nontrivial_copy_assignment&) = default; + nontrivial_copy_assignment(nontrivial_copy_assignment&&) = default; + nontrivial_copy_assignment& operator=(const nontrivial_copy_assignment&) &; +}; + +struct nontrivial_move_assignment { + nontrivial_move_assignment(const nontrivial_move_assignment&) = default; + nontrivial_move_assignment(nontrivial_move_assignment&&) = default; + nontrivial_move_assignment& operator=(nontrivial_move_assignment&&) &; +}; + +struct trivially_copy_constructible { + trivially_copy_constructible(const trivially_copy_constructible&) = default; + trivially_copy_constructible(trivially_copy_constructible&&) = delete; + unconstructible _1; + deleted_assignment _2; +}; + +struct trivially_copy_assignable { + unconstructible _1; + deleted_copy_move _2; + trivially_copy_assignable& operator=(trivially_copy_assignable const&) & = default; + trivially_copy_assignable& operator=(trivially_copy_assignable&&) & = delete; +}; + +struct trivially_copyable { + deleted_move_constructor _1; + deleted_move_assignment _2; + nontrivial_default_constructor _3; +}; + +struct trivially_movable { + deleted_copy_constructor _1; + deleted_copy_assignment _2; + nontrivial_default_constructor _3; +}; + +struct trivially_destructible { + nontrivial_default_constructor _1; + nontrivial_copy_constructor _2; + nontrivial_move_constructor _3; + nontrivial_copy_assignment _4; + nontrivial_move_assignment _5; +}; + +enum class special_member_kind { + undeclared, + defaulted, + deleted, + nontrivial, +}; + +using special_member_kind = special_member_kind; + +namespace specmem_specials { + +template +struct S; + +#include "./detail/special_mems.ipp" + +} // namespace specmem_specials + +struct special_members_params { + special_member_kind default_constructor = special_member_kind::undeclared; + special_member_kind destructor = special_member_kind::undeclared; + special_member_kind copy_constructor = special_member_kind::undeclared; + special_member_kind move_constructor = special_member_kind::undeclared; + special_member_kind copy_assignment = special_member_kind::undeclared; + special_member_kind move_assignment = special_member_kind::undeclared; +}; + +template +using special_members_t = specmem_specials::S; + } // namespace neo::arch NEO_PRAGMA_WARNING_POP(); diff --git a/src/neo/archetypes.test.cpp b/src/neo/archetypes.test.cpp index 3a8b768..dbc31ec 100644 --- a/src/neo/archetypes.test.cpp +++ b/src/neo/archetypes.test.cpp @@ -1,4 +1,5 @@ #include "./archetypes.hpp" +#include "./concepts.hpp" #include @@ -26,18 +27,14 @@ static_assert(!neo::destructible && // !neo::movable); template -concept can_amp_addressof = requires(T& arg) { - &arg; -}; +concept can_amp_addressof = requires(T& arg) { &arg; }; class derived_pathological : pathological {}; static_assert(!can_amp_addressof); static_assert(!can_amp_addressof); template -concept can_comma_operate = requires(T& arg) { - (arg, 0); -}; +concept can_comma_operate = requires(T& arg) { (arg, 0); }; static_assert(!can_comma_operate); static_assert(!can_comma_operate); @@ -79,3 +76,46 @@ static_assert(!neo::regular); static_assert(neo::regular); static_assert(neo::invocable, int, char, int*>); + +static_assert(neo::trivially_default_constructible); +static_assert(not neo::trivially_constructible); +static_assert(not neo::trivially_constructible); +static_assert(not neo::trivially_copyable); +static_assert(not neo::trivially_assignable); +static_assert(not neo::trivially_assignable); +// XXX: https://cplusplus.github.io/LWG/issue2116 +// static_assert(not neo::trivially_destructible); + +static_assert(not neo::default_initializable); +static_assert(neo::trivially_constructible); +static_assert(not neo::trivially_assignable); +static_assert( + not neo::trivially_assignable); +static_assert( + not neo::trivially_constructible); + +static_assert(not neo::default_initializable); +static_assert( + not neo::trivially_constructible); +static_assert( + neo::trivially_assignable); +static_assert( + not neo::trivially_assignable); +static_assert( + not neo::trivially_constructible); + +static_assert(neo::trivially_copyable); +static_assert(neo::trivially_movable); +static_assert(neo::trivially_movable); +static_assert(not neo::copyable); + +static_assert(neo::trivially_destructible); +static_assert(not neo::trivially_default_constructible); +static_assert(not neo::trivially_copyable); +static_assert(not neo::trivially_movable); diff --git a/src/neo/arrow_proxy.hpp b/src/neo/arrow_proxy.hpp index 49025c0..33807d3 100644 --- a/src/neo/arrow_proxy.hpp +++ b/src/neo/arrow_proxy.hpp @@ -1,7 +1,7 @@ #pragma once #include "./addressof.hpp" -#include "./scalar_box.hpp" +#include "./object_box.hpp" namespace neo { @@ -12,7 +12,7 @@ namespace neo { */ template class arrow_proxy { - NEO_NO_UNIQUE_ADDRESS scalar_box _value; + NEO_NO_UNIQUE_ADDRESS object_box _value; public: explicit constexpr arrow_proxy(T&& t) noexcept diff --git a/src/neo/assert.hpp b/src/neo/assert.hpp index 9a61c65..e979e6f 100644 --- a/src/neo/assert.hpp +++ b/src/neo/assert.hpp @@ -18,10 +18,10 @@ // A noexcept-attribute that is only `noexcept` if the assertion handler does not throw #define NEO_NOEXCEPT_ASSERTS noexcept(NEO_ASSERT_IS_NOEXCEPT) -#if NEO_COMPILER_IS_MSVC +#if NEO_COMPILER(MSVC) // MSVC has an __assume built-in #define NEO_ASSUME_1(...) (__assume(__VA_ARGS__), true) -#elif NEO_COMPILER_IS_CLANG +#elif NEO_COMPILER(Clang) // Clang defines a similar built-in to the MSVC one #define NEO_ASSUME_1(...) (__builtin_assume(__VA_ARGS__), true) #else @@ -35,7 +35,7 @@ */ #define NEO_ASSUME(...) NEO_ASSUME_1(__VA_ARGS__) -#if NEO_COMPILER_IS_MSVC || NEO_COMPILER_IS_CLANG +#if NEO_COMPILER(MSVC, Clang) // On _MSC_VER and __clang__, we have an `assume` intrinsic that does not evaluate its argument. #define NEO_UNEVAL_ASSUME_1(...) (NEO_ASSUME(__VA_ARGS__), true) #else @@ -57,9 +57,9 @@ namespace neo { * definition, is undefined behavior. Use this an optimization hint. */ [[noreturn]] NEO_ALWAYS_INLINE void unreachable() noexcept { -#if NEO_COMPILER_IS_GNU_LIKE +#if NEO_COMPILER(Clang, GNU) __builtin_unreachable(); -#elif NEO_COMPILER_IS_MSVC +#elif NEO_COMPILER(MSVC) __assume(0); #endif } @@ -149,9 +149,7 @@ struct assertion_expression { namespace detail { template -concept ostream_writable = requires(std::ostream& out, const T& value) { - out << value; -}; +concept ostream_writable = requires(std::ostream& out, const T& value) { out << value; }; template constexpr void check_one_representable(T&&) noexcept { @@ -346,9 +344,9 @@ fire_assertion(assertion_info info, // compile flag. Check that we have it ready. #if _MSVC_TRADITIONAL #pragma message( \ - "warning: NOTE from neo-fun: Using the macros with MSVC " \ - "requires a C++20 conformant preprocessor. Compile with " \ - "/experimental:preprocessor") + "warning: NOTE from neo-fun: Using the macros with MSVC " \ + "requires a C++20 conformant preprocessor. Compile with " \ + "/experimental:preprocessor") #endif /** @@ -454,16 +452,14 @@ void render_breadcrumbs(std::ostream& out) noexcept; */ #define neo_assertion_breadcrumbs(Message, ...) \ ::neo::detail::breadcrumb_impl \ - NEO_CONCAT_3(_neo_breadcrum_, \ - __LINE__, \ - _scope)(Message, \ - NEO_SOURCE_LOCATION(), \ - [&](const ::neo::detail::breadcrumb_base& self, \ - std::ostream& out) noexcept { \ - self.render_into(out, \ - 0 NEO_MAP(NEO_REPR_ASSERT_EXPR, \ - ~, \ - __VA_ARGS__)); \ - }) + NEO_CONCAT_3(_neo_breadcrum_, \ + __LINE__, \ + _scope)(Message, \ + NEO_SOURCE_LOCATION(), \ + [&](const ::neo::detail::breadcrumb_base& self, \ + std::ostream& out) noexcept { \ + self.render_into(out, \ + 0 NEO_MAP(NEO_REPR_ASSERT_EXPR, ~, __VA_ARGS__)); \ + }) } // namespace neo diff --git a/src/neo/assignable_box.hpp b/src/neo/assignable_box.hpp index a036508..fbc90ac 100644 --- a/src/neo/assignable_box.hpp +++ b/src/neo/assignable_box.hpp @@ -1,6 +1,6 @@ #pragma once -#include "./scalar_box.hpp" +#include "./object_box.hpp" #if defined(__bpt_header_check) #include "./platform.hpp" @@ -11,8 +11,8 @@ NEO_MSVC_PRAGMA(warning(disable : 4996)); namespace neo { template -struct [[deprecated("Use scalar_box instead of assignable_box")]] assignable_box : scalar_box { - using assignable_box::scalar_box::scalar_box; +struct [[deprecated("Use object_box instead of assignable_box")]] assignable_box : object_box { + using assignable_box::object_box::object_box; }; template diff --git a/src/neo/attrib.hpp b/src/neo/attrib.hpp index 1994e48..e8966d4 100644 --- a/src/neo/attrib.hpp +++ b/src/neo/attrib.hpp @@ -4,11 +4,11 @@ #include // clang-format off -#if NEO_COMPILER_IS_MSVC +#if NEO_COMPILER(MSVC) # define NEO_ALWAYS_INLINE __forceinline # define NEO_PRETTY_FUNC __FUNCSIG__ -#elif NEO_COMPILER_IS_GNU_LIKE +#elif NEO_COMPILER(GNU, Clang) # define NEO_ALWAYS_INLINE [[gnu::always_inline]] inline # define NEO_PRETTY_FUNC __PRETTY_FUNCTION__ @@ -25,7 +25,7 @@ # define NEO_CONSTEXPR_DESTRUCTOR inline #endif -#if NEO_COMPILER_IS_MSVC +#if NEO_COMPILER(MSVC) # define NEO_NO_UNIQUE_ADDRESS [[msvc::no_unique_address]] #else # define NEO_NO_UNIQUE_ADDRESS [[no_unique_address]] @@ -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 +#include +#include +#include +#include + +#include +#include + +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 + static auto getit(from_channel& from) noexcept { + return from._coro; + } +}; + +/** + * @brief Abstract base class for send/yield handling + * + * @tparam T + */ +template +class io_base { +public: + /** + * @brief Push the referred-to value to the handler. + */ + virtual void put(add_lvalue_reference_t>) = 0; +}; + +/** + * @brief Implements the return value aspect of channel + * + * @tparam Derived The derived promise type (CRTP) + */ +template +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. Defines a `get() -> nonvoid_t&` method. + */ +template +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. Defines a `get() -> nonvoid_t&` method. + */ +template +struct send_io; + +template +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; + // The type yielded by the sub-channel must be convertible to the parent channel's yield type + requires convertible_to; + // Passing the yield/send values through should not construct any references to temporary + // objects: + requires not reference_constructible_from_temporary; + requires not reference_constructible_from_temporary; +}; + +/** + * @brief Promise type for channels + */ +template +class promise : public return_part> { + // The coroutine handle type for this promise + using handle_type = std::coroutine_handle; + + // Grant other promises access to our components, to allow updating the yield/send IO + template + friend class _channel_detail::promise; + + // The yield handler for this promise. + NEO_NO_UNIQUE_ADDRESS yield_io> _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> _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>* _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>* _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>** _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& arg) { this->_sender->put(arg); } + + /** + * @brief Obtain a reference to the yielded value. If `void`, then returns + * a `unit&` + */ + nonvoid_t& get_yielded() noexcept { + return static_cast&>(_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 + 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>(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&> yield_value(nonvoid_t&& y) noexcept { + return {*this, y}; + } + + template + requires reference_constructible_from_temporary + [[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> yield_value(nonvoid_t const& y) noexcept + // This overload is only visible for non-lref types: + requires(not reference_type) + // We must be able to copy to the underlying type + and convertible_to 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 + struct nested_awaiter; + + template + struct nested_awaiter>> { + using OtherHandle = std::coroutine_handle>; + 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> { + io_base>* _send_child; + + void put(add_lvalue_reference_t> s) { _send_child->put(s); } + }; + + struct yielder_link : io_base> { + io_base>* _parent_yield; + + void put(nonvoid_t& s) { _parent_yield->put(s); } + }; + + sender_link _sender2{}; + yielder_link _yielder2{}; + + io_base>* + get_sender_link(io_base>* child_sender) { + if constexpr (weak_same_as) { + return child_sender; + } else { + _sender2._send_child = child_sender; + return &_sender2; + } + } + + io_base>* + get_yielder_link(io_base>* parent_yielder) { + if constexpr (weak_same_as) { + 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>( + child_co_handle.promise().get_returned()); + } + }; + + template + requires nested_channel_yield_compatible + auto yield_value(from_channel> from) { + auto other_co = from_chan_coro_getter::getit(from); + return nested_awaiter{*this, other_co}; + } +}; + +template +struct promise_base; + +template +struct return_part> { + using Derived = promise; + + optional _retval; + + constexpr Return& get_returned() noexcept { return *_retval; } + + template Arg> + constexpr void return_value(Arg&& arg) { + _retval.emplace(NEO_FWD(arg)); + } +}; + +template +struct return_part> { + constexpr void return_void() noexcept {} + constexpr unit get_returned() noexcept { return {}; } +}; + +template +struct send_io : io_base { + explicit send_io(std::coroutine_handle<> co) noexcept + : resumer(co) {} + add_pointer_t ptr; + std::coroutine_handle<> resumer; + + void put(Ref ref) { + ptr = NEO_ADDRESSOF(ref); + resumer.resume(); + } + Ref get() const noexcept { return *ptr; } +}; + +template +struct send_io : io_base { + 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 +struct yield_io : io_base { + add_pointer_t ptr; + void put(T ref) override { ptr = NEO_ADDRESSOF(ref); } + + T get() const noexcept { return *ptr; } +}; + +template +struct yield_io : io_base { + 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 new file mode 100644 index 0000000..4af3919 --- /dev/null +++ b/src/neo/channel.hpp @@ -0,0 +1,340 @@ +#pragma once + +#include "./channel.detail.hpp" + +#include +#include +#include +#include + +#include +#include + +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 +class channel { +public: + /// 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; + + /** + * @brief The type returned by `channel::open()`, used for communicating with + * the channel. + */ + using pipe_type = channel_pipe; + +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); + } + + // Destroy + NEO_CONSTEXPR_DESTRUCTOR ~channel() { + if (_coro) { + _coro.destroy(); + } + } + + // Move-construct + constexpr channel(channel&& o) noexcept + : _coro(o._coro) { + o._coro = nullptr; + } + + // Move-assign + constexpr channel& operator=(channel&& o) noexcept { + if (_coro) { + _coro.destroy(); + } + _coro = o._coro; + o._coro = nullptr; + return *this; + } + + /** + * @brief Return a from_channel that can be co_yielded to start a nested channel. + * + * See `from_channel` for more information. + */ + constexpr from_channel operator*() noexcept; + +private: + template + friend class from_channel; + + using handle_type = std::coroutine_handle; + +public: + class iterator { + handle_type _coro; + + friend channel; + + explicit iterator(handle_type h) noexcept + : _coro(h) {} + + struct sender { + handle_type co; + + void operator=(nonvoid_t&& send) const&& { co.promise().send_value(send); } + }; + + public: + iterator() = default; + + using difference_type = std::ptrdiff_t; + using value_type = conditional_t, remove_cvref_t, void>; + + yield_type operator*() const noexcept + requires void_type + { + return pipe_type(_coro).take_current(); + } + + sender operator*() const noexcept + requires(not void_type) + { + return sender{_coro}; + } + + iterator& operator++() { + if constexpr (void_type) { + pipe_type(_coro).send(); + } + return *this; + } + iterator operator++(int) { + ++*this; + return *this; + } + + constexpr bool operator==(std::default_sentinel_t) const noexcept { return _coro.done(); } + }; + + iterator begin() { + _coro.resume(); + return iterator(_coro); + } + + constexpr std::default_sentinel_t end() const noexcept { return {}; } + + constexpr channel(typename promise_type::init init) noexcept + : _coro(init.co) {} + +private: + handle_type _coro; +}; + +/** + * @brief Communication handle for a neo::channel + * + * Do not construct this directly. Use neo::channel::open to obtain an instance + * of this type. + */ +template +class channel_pipe { + +public: + /// 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; + + /** + * @brief Returns `true` if the channel has co_returned normally + */ + constexpr bool done() const noexcept { return _coro.done(); } + + /** + * @brief Obtain the most-recently yielded value from the channel. + * + * If `yield_type` is `void`, returns `void`. Otherwise, returns an lvalue-reference + * to the yielded value. + * + * @pre `not done()` + */ + constexpr add_lvalue_reference_t current() const noexcept { + return static_cast>(_coro.promise().get_yielded()); + } + + /** + * @brief Take the current object yielded by the channel. May move-construct + * from the underlying object if the yield type is an object type + * + * @pre `not done()` + */ + constexpr yield_type take_current() noexcept { + return static_cast>(_coro.promise().get_yielded()); + } + + /** + * @brief Send a value and resume the channel. + * + * Accepts an rvalue-reference to the send type. This overload is only + * available if the send type is not `void`. + * + * @pre `not done()` + */ + constexpr void send(nonvoid_t&& arg) + requires(not void_type) + { + _coro.promise().send_value(arg); + } + + /** + * @brief Send a value with a possible conversion, and resume the channel + * + * @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> + * + * @pre `not done()` + */ + constexpr void send(nonvoid_t const& arg) + // Require that we are not sending lvalue-references: + requires(not reference_type) + // Require that we can construct a send value from the const-reference: + and convertible_to const&, send_type> + { + nonvoid_t tmp(arg); + _coro.promise().send_value(tmp); + } + + /** + * @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 + { + unit nil; + _coro.promise().send_value(nil); + } + + /** + * @brief Obtain the final return value from the coroutine. + * + * 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_value() const noexcept { + return static_cast>(_coro.promise().get_returned()); + } + + /** + * @brief Take the final return value from the coroutine. + * + * This returns exactly yield_type, which may be an rvalue. + * + * @pre `done()` + */ + constexpr return_type take_return_value() noexcept { + return static_cast>(_coro.promise().get_returned()); + } + +private: + // Promise type for the coroutine + using promise = _channel_detail::promise; + // Coroutine handle type for the channel + using handle_type = std::coroutine_handle; + + // Allow our channel to call our constructor + friend channel; + + /** + * @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 +class from_channel { + // The wrapped channel coroutine + typename remove_cvref_t::handle_type _coro; + + friend _channel_detail::from_chan_coro_getter; + +public: + explicit from_channel(const C& c) noexcept + : _coro(c._coro) {} +}; + +// CTAD for from_channnel +template +explicit from_channel(C const&) -> from_channel; + +template +constexpr from_channel> channel::operator*() noexcept { + return from_channel(*this); +} + +} // namespace neo diff --git a/src/neo/channel.test.cpp b/src/neo/channel.test.cpp new file mode 100644 index 0000000..d15f25d --- /dev/null +++ b/src/neo/channel.test.cpp @@ -0,0 +1,438 @@ +#include "./channel.hpp" + +#include + +#include +#include +#include + +#include +#include + +using namespace neo; + +channel int_chan() { + decltype(auto) r = co_yield 21; + CHECK(r == 42); + co_return; +} + +TEST_CASE("Simple channel") { + 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 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 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 ret_int_chan() { + co_yield 0; + // Should not compile: + // auto x = co_yield 0; + co_return 42; +} + +TEST_CASE("Non-void return") { + auto ch = ret_int_chan(); + auto io = ch.open(); + REQUIRE_FALSE(io.done()); + io.send(); + CHECK(io.done()); + CHECK(io.return_value() == 42); +} + +channel 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 ret_int2_chan() { + co_yield {}; + // Should not compile: + // co_return 51; + global_int = 42; + co_return global_int; +} + +TEST_CASE("Reference return") { + auto ch = ret_int2_chan(); + auto io = ch.open(); + REQUIRE_FALSE(io.done()); + io.send(); + CHECK(io.done()); + CHECK(io.return_value() == 42); +} + +channel ret_int3_chan() { + global_int = 71; + co_yield global_int; + // Should not compile: + // co_yield 71; + global_int = 42; + co_return global_int; +} + +TEST_CASE("Reference yield") { + auto ch = ret_int3_chan(); + auto io = ch.open(); + REQUIRE_FALSE(io.done()); + CHECK(io.current() == 71); + io.send(); + CHECK(io.done()); + CHECK(io.return_value() == 42); +} + +channel inner() { + co_yield 31; + co_yield 8; +} +channel outer() { + co_yield global_int; + co_yield from_channel(inner()); +} + +TEST_CASE("Nested yield") { + global_int = 94; + auto ch = outer(); + auto io = ch.open(); + 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(); + CHECK(io.done()); +} + +channel 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 inner_with_str() { + co_yield 31; + co_return "Howdy"; +} +channel outer2() { + co_yield global_int; + auto s = co_yield from_channel(inner_with_str()); + co_yield static_cast(s.length()); +} + +TEST_CASE("Nested yield with return") { + auto ch = outer2(); + auto io = ch.open(); + REQUIRE_FALSE(io.done()); + global_int = 94; + CHECK(io.current() == 94); + io.send(); + REQUIRE_FALSE(io.done()); + CHECK(io.current() == 31); + REQUIRE_FALSE(io.done()); + io.send(); + CHECK(io.current() == 5); + REQUIRE_FALSE(io.done()); + io.send(); + CHECK(io.done()); +} + +channel my_chan() { + decltype(auto) s = co_yield "Hello"; + static_assert(neo::same_as); + CHECK(s == "world!"); + co_return "the end"; +} + +TEST_CASE("Nontrivial objects") { + auto ch = my_chan(); + auto io = ch.open(); + REQUIRE_FALSE(io.done()); + CHECK(io.current() == "Hello"); + CHECK(io.current() == "Hello"); // Check again to be sure it isn't moved-from + io.send("world!"); + REQUIRE(io.done()); + CHECK(io.return_value() == "the end"); + CHECK(io.return_value() == "the end"); +} + +channel throwing_channel(int) { + const auto s = co_yield "Howdy!"; + throw std::runtime_error("fail"); + co_return "hi"; +} + +TEST_CASE("Throw an error") { + auto ch = throwing_channel(3); + auto io = ch.open(); + REQUIRE_FALSE(io.done()); + CHECK_THROWS_AS(io.send("boo"), std::runtime_error); + CHECK(io.done()); +} + +channel throwing_channel2(int) { + throw std::runtime_error("fail"); + co_return "hi"; +} + +TEST_CASE("Throw an error 2") { + auto ch = throwing_channel2(3); + CHECK_THROWS_AS(ch.open(), std::runtime_error); +} + +channel<> maybe_throw(bool do_throw) { + if (do_throw) { + throw std::runtime_error("no"); + } + co_return; +} +channel<> inner_loop() { + std::vector vec(1024); + co_yield *maybe_throw(false); + co_yield *maybe_throw(true); + co_yield *maybe_throw(false); +} + +channel<> outer_loop() { + auto ch = inner_loop(); + auto io = ch.open(); + io.send(); + io.send(); + co_return; +} + +TEST_CASE("Throw during suspend") { + if (not NEO_IsEnabled(NEO_Clang_Broken_Coroutines)) { + auto ch = outer_loop(); + CHECK_THROWS_AS(ch.open(), std::runtime_error); + } +} + +channel deep_channel(int layers) { + if (layers == 0) { + int got = co_yield 42; + CHECK(got == 1729); + } else { + co_yield layers; + co_yield *deep_channel(layers - 1); + co_yield layers; + } +} + +TEST_CASE("Deep resume") { + const int nlayers = 4096; + auto ch = deep_channel(nlayers); + auto io = ch.open(); + for (int n = nlayers; n > 0; --n) { + REQUIRE_FALSE(io.done()); + CHECK(io.current() == n); + io.send(-12); + } + CHECK(io.current() == 42); + io.send(1729); + for (int n = 1; n <= nlayers; ++n) { + REQUIRE_FALSE(io.done()); + CHECK(io.current() == n); + io.send(-2); + } + CHECK(io.done()); +} + +channel deep_return(int n, int top) { + if (n == 0) { + co_return top; + } + co_return co_yield *deep_return(n - 1, top); +} + +TEST_CASE("Deep return") { + auto ch = deep_return(2, 52); + auto io = ch.open(); + CHECK(io.return_value() == 52); +} + +neo::channel integer_mrefs() { + int n = 0; + co_yield n; +} + +neo::channel generate_fib() { + int a = 0; + int b = 1; + for (;;) { + co_yield a; + int sum = a + b; + a = b; + b = sum; + } + neo::unreachable(); + co_return "unreachable"; +} + +static_assert(std::input_iterator>>); +static_assert(std::ranges::range>); +static_assert(std::ranges::input_range>); +static_assert(std::ranges::output_range, int>); +static_assert(not std::ranges::input_range>); + +TEST_CASE("As range") { + auto ch = generate_fib(); + std::vector nums; + std::ranges::copy(std::views::take(ch, 40), std::back_inserter(nums)); + CHECK(nums[39] == 63245986); +} + +template +neo::channel push_backer(std::vector& into) { + while (1) { + auto t = co_yield 42.0; + into.push_back(NEO_FWD(t)); + } +} + +TEST_CASE("Output range") { + std::vector strings; + auto out = push_backer(strings); + auto num_strings + = std::views::iota(0, 30) | std::views::transform([](auto n) { return std::to_string(n); }); + std::ranges::copy(num_strings, out.begin()); + CHECK(strings.size() == 30); +} + +neo::channel inner_throws() { + throw std::runtime_error("fail"); + co_return; +} + +neo::channel outer_catches() { + try { + co_yield *inner_throws(); + FAIL("Child did not throw, but we expected it"); + } catch (std::runtime_error const&) { + co_return; + } +} + +neo::channel outer_unaware() { co_yield *outer_catches(); } + +TEST_CASE("Nested throw") { + auto ch = outer_unaware(); + CHECK_NOTHROW(ch.open()); +} + +struct ref_conversion { + static channel get_strings() { + std::string s = "Joe"; + co_yield s; + } + static channel get_string_values() { + co_yield "value-string"; // + } + static channel get_cstrings() { + co_yield "c-string"; // + } + static channel get_cstrings_cref() { + co_yield "c-string-cref"; // + } + static channel get_integers() { + int i = 21; + co_yield i; + } + static channel 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 new file mode 100644 index 0000000..39b2e8c --- /dev/null +++ b/src/neo/channel_fwd.hpp @@ -0,0 +1,24 @@ +#pragma once + +namespace neo { + +template +class channel; + +template +class channel_pipe; + +/** + * @brief Generate a co_yield-able expression that can be used to delegate to + * another channel. + * + * @tparam C The channel type to yield from + * + * The yielded channel must have compatible send and yield types. The return + * value from the inner channel will be the result of the co_yield expression + * in the delegating coroutine. + */ +template +class from_channel; + +} // namespace neo diff --git a/src/neo/co_resource.test.cpp b/src/neo/co_resource.test.cpp index 3ff34e5..0a1948d 100644 --- a/src/neo/co_resource.test.cpp +++ b/src/neo/co_resource.test.cpp @@ -1,6 +1,7 @@ #if __cpp_impl_coroutine #include "./co_resource.hpp" +#include "./coroutine.hpp" #include @@ -60,4 +61,79 @@ neo::co_resource with_throws() { TEST_CASE("Throws in setup") { CHECK_THROWS_AS(with_throws(), std::runtime_error); } +#if !NEO_IsEnabled(NEO_GCC_Broken_Coroutines) +enum rc_state { + init, + in_coro, + about_to_convert, + converted, + constructed, + used_resource, + destroyed, + coro_done, +}; + +struct rc_type { + rc_state& st; + + rc_type(rc_state& s) + : st{s} { + assert(st == converted); + st = constructed; + } + + ~rc_type() { + assert(st == used_resource); + st = destroyed; + } +}; + +struct rc_convert { + rc_state& st; + + explicit rc_convert(rc_state& s) + : st{s} { + assert(st == in_coro); + st = about_to_convert; + } + + operator rc_type() { + assert(st == about_to_convert); + st = converted; + return rc_type{st}; + } +}; + +neo::co_resource get_resource(rc_state& st) { + assert(st == init); + st = in_coro; + co_yield rc_convert{st}; + assert(st == destroyed); + st = coro_done; +} + +TEST_CASE("co_rc lifetimes") { + rc_state state = init; + { + auto res = get_resource(state); + assert(state == constructed); + state = used_resource; + } + assert(state == coro_done); +} + +struct stuff { + std::string a; + std::string b; +}; + +neo::co_resource get_stuff() { co_yield {"foo", "bar"}; } + +TEST_CASE("Use some stuff") { + auto s = get_stuff(); + CHECK(s->a == "foo"); + CHECK(s->b == "bar"); +} +#endif + #endif 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 + +#include + +namespace neo { + +struct synth_three_way_fn { + template U> + NEO_ALWAYS_INLINE constexpr std::compare_three_way_result_t + operator()(const T& t, const U& u) const noexcept { + return t <=> u; + } + + template + requires(not three_way_comparable_with) + 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 +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 af686f7..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 concept constructible_from = destructible - 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 + #endif ; /// Check whether one can static_cast(From) @@ -249,7 +255,9 @@ concept swappable_with = detail::swappable_impl; * @brief Test whether a type is swappable with itself via std::ranges::swap */ template -concept swappable = detail::can_std_ranges_swap; +concept swappable = requires(T& t) { + neo::swap(t, t); +} or detail::can_std_ranges_swap; namespace detail { @@ -408,9 +416,20 @@ concept nothrow_constructible_from = #endif ; +template +concept move_assignable = + move_constructible + and assignable_from; + +template +concept copy_assignable = + move_assignable + and copy_constructible + and assignable_from; + template concept trivially_constructible = - constructible_from + nothrow_constructible_from and neo_is_trivially_constructible(T, Args...); template @@ -423,23 +442,45 @@ concept trivially_destructible = destructible and neo_is_trivially_destructible(T) ; -template -concept trivially_copyable = - copyable - and neo_is_trivially_copyayable(T) - ; - template concept trivially_assignable = assignable_from and neo_is_trivially_assignable(To, From); +template +concept trivially_move_constructible = + move_constructible + and trivially_constructible; + +template +concept trivially_copy_constructible = + copy_constructible + and trivially_constructible; + +template +concept trivially_copy_assignable = + copy_assignable + and trivially_assignable; + +template +concept trivially_move_assignable = + move_assignable + and trivially_assignable; + template concept trivially_movable = movable - and trivially_constructible + and trivially_move_constructible and trivially_assignable; +template +concept trivially_copyable = + copyable + and trivially_copy_constructible + and trivially_movable + and neo_is_trivially_copyayable(T) + ; + template concept trivial_type = trivially_copyable && neo_is_trivial(T); @@ -450,6 +491,55 @@ concept nothrow_invocable = { neo::invoke(NEO_FWD(fn), NEO_FWD(args)...) } noexcept; }; +namespace detail { + +template +struct narrowing_conversion_helper { + T one[1]; +}; + +} // namespace detail + +/** + * @brief Check that `From` is convertible to `To` without causing built-in + * narrowing. + */ +template +concept non_narrowing_convertible_to = + convertible_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>{{NEO_FWD(from)}}; + }; + // clang-format on +namespace detail { + +template +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> + // If we can convert to the reference' value type, then a conversion might occur + and constructible_from, 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>>; + +} // namespace detail + +#if NEO_HAS_BUILTIN(__reference_constructs_from_temporary) +template +concept reference_constructible_from_temporary + = __reference_constructs_from_temporary(Reference, From); +#else +template +concept reference_constructible_from_temporary // + = reference_type // + and constructible_from // + and detail::best_guest_ref_from_tmp; +#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); +static_assert(not non_narrowing_convertible_to); +static_assert(non_narrowing_convertible_to); +static_assert(not non_narrowing_convertible_to); +static_assert(not non_narrowing_convertible_to); +static_assert(non_narrowing_convertible_to); + static_assert(destructible); + +TEST_CASE("reference_constructible_from_temporary") { + STATIC_REQUIRE(not reference_constructible_from_temporary); + STATIC_REQUIRE(not reference_constructible_from_temporary); + STATIC_REQUIRE(not reference_constructible_from_temporary); + STATIC_REQUIRE(not reference_constructible_from_temporary); + STATIC_REQUIRE(not reference_constructible_from_temporary); + STATIC_REQUIRE(reference_constructible_from_temporary); + STATIC_REQUIRE(reference_constructible_from_temporary); + STATIC_REQUIRE(reference_constructible_from_temporary); + STATIC_REQUIRE(not reference_constructible_from_temporary); + STATIC_REQUIRE(not reference_constructible_from_temporary); +} 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 +#include +#include +#include +#include +#include + +#include // std::construct_at + +namespace neo { + +/** + * @brief A variadic union template that is default-constructible and `constexpr`-ready. + * + * Defines three member function templates: + * + * - `get() -> nth_type [const] [&|&&]` obtain a reference to the `Nth` union member. + * - `construct(auto&&...) -> nth_type&` activate the `Nth` union member by calling + * the constructor with the given arguments. No other union members are modified. + * - `destroy() -> 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()` 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` 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` 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 +union constexpr_union; + +namespace detail { + +template +concept all_trivially_destructible = + (neo_is_trivially_destructible(Ts) and ... and true); + +template +NEO_ALWAYS_INLINE constexpr Ret get_member(Onion&& on) noexcept { + if constexpr (N == 0) return static_cast(on._0); + if constexpr (N == 1) return static_cast(on._1); + if constexpr (N == 2) return static_cast(on._2); + if constexpr (N == 3) return static_cast(on._3); + if constexpr (N == 4) return static_cast(on._4); + if constexpr (N == 5) return static_cast(on._5); + if constexpr (N == 6) return static_cast(on._6); + if constexpr (N == 7) return static_cast(on._7); + if constexpr (N == 8) return static_cast(on._8); + if constexpr (N == 9) return static_cast(on._9); + if constexpr (N == 10) return static_cast(on._10); + if constexpr (N == 11) return static_cast(on._11); + if constexpr (N == 12) return static_cast(on._12); + if constexpr (N == 13) return static_cast(on._13); + if constexpr (N == 14) return static_cast(on._14); + if constexpr (N == 15) return static_cast(on._15); + if constexpr (N == 16) return static_cast(on._16); + if constexpr (N == 17) return static_cast(on._17); + if constexpr (N == 18) return static_cast(on._18); + if constexpr (N == 19) return static_cast(on._19); + if constexpr (N == 20) return static_cast(on._20); + if constexpr (N == 21) return static_cast(on._21); + if constexpr (N == 22) return static_cast(on._22); + if constexpr (N == 23) return static_cast(on._23); + if constexpr (N == 24) return static_cast(on._24); + if constexpr (N == 25) return static_cast(on._25); + if constexpr (N == 26) return static_cast(on._26); + if constexpr (N == 27) return static_cast(on._27); + if constexpr (N == 28) return static_cast(on._28); + if constexpr (N == 29) return static_cast(on._29); + if constexpr (N == 30) return static_cast(on._30); + if constexpr (N == 31) return static_cast(on._31); + if constexpr (N == 32) return static_cast(on._32); + if constexpr (N == 33) return static_cast(on._33); + if constexpr (N == 34) return static_cast(on._34); + if constexpr (N == 35) return static_cast(on._35); + if constexpr (N == 36) return static_cast(on._36); + if constexpr (N == 37) return static_cast(on._37); + if constexpr (N == 38) return static_cast(on._38); + if constexpr (N == 39) return static_cast(on._39); + if constexpr (N == 40) return static_cast(on._40); + if constexpr (N == 41) return static_cast(on._41); + if constexpr (N == 42) return static_cast(on._42); + if constexpr (N == 43) return static_cast(on._43); + if constexpr (N == 44) return static_cast(on._44); + if constexpr (N == 45) return static_cast(on._45); + if constexpr (N == 46) return static_cast(on._46); + if constexpr (N == 47) return static_cast(on._47); + if constexpr (N == 48) return static_cast(on._48); + if constexpr (N == 49) return static_cast(on._49); + if constexpr (N == 50) return static_cast(on._50); + if constexpr (N == 51) return static_cast(on._51); + if constexpr (N == 52) return static_cast(on._52); + if constexpr (N == 53) return static_cast(on._53); + if constexpr (N == 54) return static_cast(on._54); + if constexpr (N == 55) return static_cast(on._55); + if constexpr (N == 56) return static_cast(on._56); + if constexpr (N == 57) return static_cast(on._57); + if constexpr (N == 58) return static_cast(on._58); + if constexpr (N == 59) return static_cast(on._59); + if constexpr (N == 60) return static_cast(on._60); + if constexpr (N == 61) return static_cast(on._61); + if constexpr (N == 62) return static_cast(on._62); + if constexpr (N == 63) return static_cast(on._63); + if constexpr (N == 64) return static_cast(on._64); + if constexpr (N == 65) return static_cast(on._65); + if constexpr (N == 66) return static_cast(on._66); + if constexpr (N == 67) return static_cast(on._67); + if constexpr (N == 68) return static_cast(on._68); + if constexpr (N == 69) return static_cast(on._69); + if constexpr (N == 70) return static_cast(on._70); + if constexpr (N == 71) return static_cast(on._71); + if constexpr (N == 72) return static_cast(on._72); + if constexpr (N == 73) return static_cast(on._73); + if constexpr (N == 74) return static_cast(on._74); + if constexpr (N == 75) return static_cast(on._75); + if constexpr (N == 76) return static_cast(on._76); + if constexpr (N == 77) return static_cast(on._77); + if constexpr (N == 78) return static_cast(on._78); + if constexpr (N == 79) return static_cast(on._79); + if constexpr (N == 80) return static_cast(on._80); + if constexpr (N == 81) return static_cast(on._81); + if constexpr (N == 82) return static_cast(on._82); + if constexpr (N == 83) return static_cast(on._83); + if constexpr (N == 84) return static_cast(on._84); + if constexpr (N == 85) return static_cast(on._85); + if constexpr (N == 86) return static_cast(on._86); + if constexpr (N == 87) return static_cast(on._87); + if constexpr (N == 88) return static_cast(on._88); + if constexpr (N == 89) return static_cast(on._89); + if constexpr (N == 90) return static_cast(on._90); + if constexpr (N == 91) return static_cast(on._91); + if constexpr (N == 92) return static_cast(on._92); + if constexpr (N == 93) return static_cast(on._93); + if constexpr (N == 94) return static_cast(on._94); + if constexpr (N == 95) return static_cast(on._95); + if constexpr (N == 96) return static_cast(on._96); + if constexpr (N == 97) return static_cast(on._97); + if constexpr (N == 98) return static_cast(on._98); + if constexpr (N == 99) return static_cast(on._99); +} + +template +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)...); + if constexpr (N == 1) return std::construct_at(NEO_ADDRESSOF(on._1), static_cast(args)...); + if constexpr (N == 2) return std::construct_at(NEO_ADDRESSOF(on._2), static_cast(args)...); + if constexpr (N == 3) return std::construct_at(NEO_ADDRESSOF(on._3), static_cast(args)...); + if constexpr (N == 4) return std::construct_at(NEO_ADDRESSOF(on._4), static_cast(args)...); + if constexpr (N == 5) return std::construct_at(NEO_ADDRESSOF(on._5), static_cast(args)...); + if constexpr (N == 6) return std::construct_at(NEO_ADDRESSOF(on._6), static_cast(args)...); + if constexpr (N == 7) return std::construct_at(NEO_ADDRESSOF(on._7), static_cast(args)...); + if constexpr (N == 8) return std::construct_at(NEO_ADDRESSOF(on._8), static_cast(args)...); + if constexpr (N == 9) return std::construct_at(NEO_ADDRESSOF(on._9), static_cast(args)...); + if constexpr (N == 10) return std::construct_at(NEO_ADDRESSOF(on._10), static_cast(args)...); + if constexpr (N == 11) return std::construct_at(NEO_ADDRESSOF(on._11), static_cast(args)...); + if constexpr (N == 12) return std::construct_at(NEO_ADDRESSOF(on._12), static_cast(args)...); + if constexpr (N == 13) return std::construct_at(NEO_ADDRESSOF(on._13), static_cast(args)...); + if constexpr (N == 14) return std::construct_at(NEO_ADDRESSOF(on._14), static_cast(args)...); + if constexpr (N == 15) return std::construct_at(NEO_ADDRESSOF(on._15), static_cast(args)...); + if constexpr (N == 16) return std::construct_at(NEO_ADDRESSOF(on._16), static_cast(args)...); + if constexpr (N == 17) return std::construct_at(NEO_ADDRESSOF(on._17), static_cast(args)...); + if constexpr (N == 18) return std::construct_at(NEO_ADDRESSOF(on._18), static_cast(args)...); + if constexpr (N == 19) return std::construct_at(NEO_ADDRESSOF(on._19), static_cast(args)...); + if constexpr (N == 20) return std::construct_at(NEO_ADDRESSOF(on._20), static_cast(args)...); + if constexpr (N == 21) return std::construct_at(NEO_ADDRESSOF(on._21), static_cast(args)...); + if constexpr (N == 22) return std::construct_at(NEO_ADDRESSOF(on._22), static_cast(args)...); + if constexpr (N == 23) return std::construct_at(NEO_ADDRESSOF(on._23), static_cast(args)...); + if constexpr (N == 24) return std::construct_at(NEO_ADDRESSOF(on._24), static_cast(args)...); + if constexpr (N == 25) return std::construct_at(NEO_ADDRESSOF(on._25), static_cast(args)...); + if constexpr (N == 26) return std::construct_at(NEO_ADDRESSOF(on._26), static_cast(args)...); + if constexpr (N == 27) return std::construct_at(NEO_ADDRESSOF(on._27), static_cast(args)...); + if constexpr (N == 28) return std::construct_at(NEO_ADDRESSOF(on._28), static_cast(args)...); + if constexpr (N == 29) return std::construct_at(NEO_ADDRESSOF(on._29), static_cast(args)...); + if constexpr (N == 30) return std::construct_at(NEO_ADDRESSOF(on._30), static_cast(args)...); + if constexpr (N == 31) return std::construct_at(NEO_ADDRESSOF(on._31), static_cast(args)...); + if constexpr (N == 32) return std::construct_at(NEO_ADDRESSOF(on._32), static_cast(args)...); + if constexpr (N == 33) return std::construct_at(NEO_ADDRESSOF(on._33), static_cast(args)...); + if constexpr (N == 34) return std::construct_at(NEO_ADDRESSOF(on._34), static_cast(args)...); + if constexpr (N == 35) return std::construct_at(NEO_ADDRESSOF(on._35), static_cast(args)...); + if constexpr (N == 36) return std::construct_at(NEO_ADDRESSOF(on._36), static_cast(args)...); + if constexpr (N == 37) return std::construct_at(NEO_ADDRESSOF(on._37), static_cast(args)...); + if constexpr (N == 38) return std::construct_at(NEO_ADDRESSOF(on._38), static_cast(args)...); + if constexpr (N == 39) return std::construct_at(NEO_ADDRESSOF(on._39), static_cast(args)...); + if constexpr (N == 40) return std::construct_at(NEO_ADDRESSOF(on._40), static_cast(args)...); + if constexpr (N == 41) return std::construct_at(NEO_ADDRESSOF(on._41), static_cast(args)...); + if constexpr (N == 42) return std::construct_at(NEO_ADDRESSOF(on._42), static_cast(args)...); + if constexpr (N == 43) return std::construct_at(NEO_ADDRESSOF(on._43), static_cast(args)...); + if constexpr (N == 44) return std::construct_at(NEO_ADDRESSOF(on._44), static_cast(args)...); + if constexpr (N == 45) return std::construct_at(NEO_ADDRESSOF(on._45), static_cast(args)...); + if constexpr (N == 46) return std::construct_at(NEO_ADDRESSOF(on._46), static_cast(args)...); + if constexpr (N == 47) return std::construct_at(NEO_ADDRESSOF(on._47), static_cast(args)...); + if constexpr (N == 48) return std::construct_at(NEO_ADDRESSOF(on._48), static_cast(args)...); + if constexpr (N == 49) return std::construct_at(NEO_ADDRESSOF(on._49), static_cast(args)...); + if constexpr (N == 50) return std::construct_at(NEO_ADDRESSOF(on._50), static_cast(args)...); + if constexpr (N == 51) return std::construct_at(NEO_ADDRESSOF(on._51), static_cast(args)...); + if constexpr (N == 52) return std::construct_at(NEO_ADDRESSOF(on._52), static_cast(args)...); + if constexpr (N == 53) return std::construct_at(NEO_ADDRESSOF(on._53), static_cast(args)...); + if constexpr (N == 54) return std::construct_at(NEO_ADDRESSOF(on._54), static_cast(args)...); + if constexpr (N == 55) return std::construct_at(NEO_ADDRESSOF(on._55), static_cast(args)...); + if constexpr (N == 56) return std::construct_at(NEO_ADDRESSOF(on._56), static_cast(args)...); + if constexpr (N == 57) return std::construct_at(NEO_ADDRESSOF(on._57), static_cast(args)...); + if constexpr (N == 58) return std::construct_at(NEO_ADDRESSOF(on._58), static_cast(args)...); + if constexpr (N == 59) return std::construct_at(NEO_ADDRESSOF(on._59), static_cast(args)...); + if constexpr (N == 60) return std::construct_at(NEO_ADDRESSOF(on._60), static_cast(args)...); + if constexpr (N == 61) return std::construct_at(NEO_ADDRESSOF(on._61), static_cast(args)...); + if constexpr (N == 62) return std::construct_at(NEO_ADDRESSOF(on._62), static_cast(args)...); + if constexpr (N == 63) return std::construct_at(NEO_ADDRESSOF(on._63), static_cast(args)...); + if constexpr (N == 64) return std::construct_at(NEO_ADDRESSOF(on._64), static_cast(args)...); + if constexpr (N == 65) return std::construct_at(NEO_ADDRESSOF(on._65), static_cast(args)...); + if constexpr (N == 66) return std::construct_at(NEO_ADDRESSOF(on._66), static_cast(args)...); + if constexpr (N == 67) return std::construct_at(NEO_ADDRESSOF(on._67), static_cast(args)...); + if constexpr (N == 68) return std::construct_at(NEO_ADDRESSOF(on._68), static_cast(args)...); + if constexpr (N == 69) return std::construct_at(NEO_ADDRESSOF(on._69), static_cast(args)...); + if constexpr (N == 70) return std::construct_at(NEO_ADDRESSOF(on._70), static_cast(args)...); + if constexpr (N == 71) return std::construct_at(NEO_ADDRESSOF(on._71), static_cast(args)...); + if constexpr (N == 72) return std::construct_at(NEO_ADDRESSOF(on._72), static_cast(args)...); + if constexpr (N == 73) return std::construct_at(NEO_ADDRESSOF(on._73), static_cast(args)...); + if constexpr (N == 74) return std::construct_at(NEO_ADDRESSOF(on._74), static_cast(args)...); + if constexpr (N == 75) return std::construct_at(NEO_ADDRESSOF(on._75), static_cast(args)...); + if constexpr (N == 76) return std::construct_at(NEO_ADDRESSOF(on._76), static_cast(args)...); + if constexpr (N == 77) return std::construct_at(NEO_ADDRESSOF(on._77), static_cast(args)...); + if constexpr (N == 78) return std::construct_at(NEO_ADDRESSOF(on._78), static_cast(args)...); + if constexpr (N == 79) return std::construct_at(NEO_ADDRESSOF(on._79), static_cast(args)...); + if constexpr (N == 80) return std::construct_at(NEO_ADDRESSOF(on._80), static_cast(args)...); + if constexpr (N == 81) return std::construct_at(NEO_ADDRESSOF(on._81), static_cast(args)...); + if constexpr (N == 82) return std::construct_at(NEO_ADDRESSOF(on._82), static_cast(args)...); + if constexpr (N == 83) return std::construct_at(NEO_ADDRESSOF(on._83), static_cast(args)...); + if constexpr (N == 84) return std::construct_at(NEO_ADDRESSOF(on._84), static_cast(args)...); + if constexpr (N == 85) return std::construct_at(NEO_ADDRESSOF(on._85), static_cast(args)...); + if constexpr (N == 86) return std::construct_at(NEO_ADDRESSOF(on._86), static_cast(args)...); + if constexpr (N == 87) return std::construct_at(NEO_ADDRESSOF(on._87), static_cast(args)...); + if constexpr (N == 88) return std::construct_at(NEO_ADDRESSOF(on._88), static_cast(args)...); + if constexpr (N == 89) return std::construct_at(NEO_ADDRESSOF(on._89), static_cast(args)...); + if constexpr (N == 90) return std::construct_at(NEO_ADDRESSOF(on._90), static_cast(args)...); + if constexpr (N == 91) return std::construct_at(NEO_ADDRESSOF(on._91), static_cast(args)...); + if constexpr (N == 92) return std::construct_at(NEO_ADDRESSOF(on._92), static_cast(args)...); + if constexpr (N == 93) return std::construct_at(NEO_ADDRESSOF(on._93), static_cast(args)...); + if constexpr (N == 94) return std::construct_at(NEO_ADDRESSOF(on._94), static_cast(args)...); + if constexpr (N == 95) return std::construct_at(NEO_ADDRESSOF(on._95), static_cast(args)...); + if constexpr (N == 96) return std::construct_at(NEO_ADDRESSOF(on._96), static_cast(args)...); + if constexpr (N == 97) return std::construct_at(NEO_ADDRESSOF(on._97), static_cast(args)...); + if constexpr (N == 98) return std::construct_at(NEO_ADDRESSOF(on._98), static_cast(args)...); + if constexpr (N == 99) return std::construct_at(NEO_ADDRESSOF(on._99), static_cast(args)...); +} + +template +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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + if constexpr (false) {} + else if constexpr (N == 0) + return (_0); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + if constexpr (false) {} + else if constexpr (N == 0) + return (_0); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + if constexpr (false) {} + else if constexpr (N == 0) + return (_0); + else if constexpr (N == 1) + return (_1); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + if constexpr (false) {} + else if constexpr (N == 0) + return (_0); + else if constexpr (N == 1) + return (_1); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type 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 + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 +union constexpr_union { + template + using nth_type = meta::pack_at; + + 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) + {} + + template + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + return detail::get_member&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + return detail::get_member const&>(*this); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 + requires(sizeof...(More) != 0) +union constexpr_union { + using FirstNext = constexpr_union; + using Tail = constexpr_union; + + 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 + using nth_type = meta::at; + + template + constexpr nth_type& get() & noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type const& get() const& noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type&& get() && noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type const&& get() const&& noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type& + construct(Args&&... args) noexcept(noexcept(nth_type(static_cast(args)...))) { + if constexpr (N < 10) { + return _first_ten.template construct(static_cast(args)...); + } else { + return _tail.template construct(static_cast(args)...); + } + } + + template + requires requires { typename nth_type; } + constexpr void destroy() noexcept { + if constexpr (N < 10) { + _first_ten.template destroy(); + } else { + _tail.template destroy(); + } + } + + 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 +#include +#include +#include +#include +#include + +#include // std::construct_at + +namespace neo { + +/** + * @brief A variadic union template that is default-constructible and `constexpr`-ready. + * + * Defines three member function templates: + * + * - `get() -> nth_type [const] [&|&&]` obtain a reference to the `Nth` union member. + * - `construct(auto&&...) -> nth_type&` activate the `Nth` union member by calling + * the constructor with the given arguments. No other union members are modified. + * - `destroy() -> 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()` 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` 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` 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 +union constexpr_union; + +namespace detail { + +template +concept all_trivially_destructible = + (neo_is_trivially_destructible(Ts) and ... and true); + +template +NEO_ALWAYS_INLINE constexpr Ret get_member(Onion&& on) noexcept { + {%- for n in range(100) %} + if constexpr (N == {{n}}) return static_cast(on._{{n}}); + {%- endfor %} +} + +template +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)...); + {%- endfor %} +} + +template +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 + using nth_type = meta::pack_at; + + 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 + NEO_ALWAYS_INLINE constexpr nth_type& construct(Args&&... args) + noexcept(noexcept(nth_type(static_cast(args)...))) + { + return *detail::construct_member(*this, static_cast(args)...); + } + + template > + NEO_ALWAYS_INLINE constexpr void destroy() noexcept { + detail::destroy_member(*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(*this); + {%- else -%} + if constexpr (false) {} + {%- call(idx, _type, member) foreach_member() %} + else if constexpr (N == {{idx}}) + return {{cast}}({{member}}); + {%- endcall -%} + {%- endif %} + {%- endmacro %} + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type& get() & noexcept { + {{ getters('', 'nth_type&') }} + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const& get() const & noexcept { + {{ getters('', 'nth_type const&') }} + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type&& get() && noexcept { + return NEO_MOVE(this->get()); + } + + template + [[nodiscard]] NEO_ALWAYS_INLINE constexpr nth_type const&& get() const && noexcept { + return NEO_MOVE(this->get()); + } + + 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 + requires(sizeof...(More) != 0) +union constexpr_union { + using FirstNext = constexpr_union; + using Tail = constexpr_union; + + 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 + using nth_type = meta::at; + + template + constexpr nth_type& get() & noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type const& get() const& noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type&& get() && noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type const&& get() const&& noexcept { + if constexpr (N < 10) { + return _first_ten.template get(); + } else { + return _tail.template get(); + } + } + + template + constexpr nth_type& + construct(Args&&... args) noexcept(noexcept(nth_type(static_cast(args)...))) { + if constexpr (N < 10) { + return _first_ten.template construct(static_cast(args)...); + } else { + return _tail.template construct(static_cast(args)...); + } + } + + template + requires requires { typename nth_type; } + constexpr void destroy() noexcept { + if constexpr (N < 10) { + _first_ten.template destroy(); + } else { + _tail.template destroy(); + } + } + + 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 + +#include +#include + +#include + +template +constexpr auto make_union(Args&&... args) { + using onion_type = neo::constexpr_union; + onion_type onion; + std::construct_at(&onion.template get(), args...); + onion.template construct(args...); + using T = typename onion_type::template nth_type; + auto dup = onion.template get(); + onion.template get().~T(); + return dup; +} + +TEST_CASE("Create a simple union") { + neo::constexpr_union 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 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 onion; + onion.construct<1>(); // Should be constexpr-okay +}; diff --git a/src/neo/core/tuple.detail.hpp b/src/neo/core/tuple.detail.hpp new file mode 100644 index 0000000..d9042b3 --- /dev/null +++ b/src/neo/core/tuple.detail.hpp @@ -0,0 +1,117 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include +#include +#include + +namespace neo::core::_tuple_detail { + +/// An indexed box to hold tuple elements +template +struct nth_box { + // The value for this element + NEO_NO_UNIQUE_ADDRESS object_t _obox; + + using lref = add_lvalue_reference_t>; + using cref = add_const_reference_t>; + + constexpr nth_box() = default; + constexpr explicit nth_box(std::in_place_t, auto&& t) + : _obox(NEO_FWD(t)) {} + + bool operator==(nth_box const&) const = default; + auto operator<=>(nth_box const&) const = default; + + constexpr lref get() noexcept { return static_cast(_obox); } + constexpr cref get() const noexcept { return static_cast(_obox); } +}; + +template >> +struct boxes; + +template +struct boxes, std::index_sequence> : nth_box... { + constexpr boxes() = default; + + template + constexpr explicit boxes(std::in_place_t tag, Args&&... args) // + : nth_box(tag, NEO_FWD(args))... {} + + bool operator==(boxes const&) const = default; + auto operator<=>(boxes const&) const = default; +}; + +template +constexpr bool equal(const auto& left, const auto& right, std::index_sequence) noexcept { + return (static_cast(left.template get() == right.template get()) and ...); +} + +template +constexpr auto compare_three_way(const T& lhs, const U& rhs, std::index_sequence) noexcept { + using Category = std::common_comparison_category_t< + std::compare_three_way_result_t()), + decltype(rhs.template get())>...>; + Category ret = std::strong_ordering::equal; + static_cast( + ((0 != (ret = synth_three_way(lhs.template get(), rhs.template get()))) or ... + or true)); + return ret; +} + +template + requires requires { std::tuple_size::value; } +using index_sequence_for_tpl = std::make_index_sequence>; + +template + requires(can_get_nth and ...) +constexpr void tuple_like_check(Tpl&& tpl, std::index_sequence); + +template +concept tuple_like = requires(Tpl&& tpl) { + typename index_sequence_for_tpl>; + tuple_like_check(static_cast(tpl), index_sequence_for_tpl>{}); +}; + +template +concept matching_tuple_like = tuple_like + and std::tuple_size_v> == std::tuple_size_v; + +template + requires( + (std::constructible_from>, get_nth_t> + and ...)) +void check_tuple_constructible(std::index_sequence); + +template +concept tuple_constructible = matching_tuple_like and requires(Argument&& from) { + check_tuple_constructible(index_sequence_for_tpl{}); +}; + +template + requires((std::convertible_to, object_t>> + and ...)) +void check_tuple_convertible(std::index_sequence); + +template +concept tuple_convertible = tuple_constructible + and requires { check_tuple_convertible(index_sequence_for_tpl{}); }; + +template + requires((nothrow_constructible_from>, + get_nth_t> + and ...)) +void check_tuple_construct_nothrow(std::index_sequence); + +template +concept tuple_construct_nothrow + = tuple_constructible and requires(Argument&& from) { + check_tuple_construct_nothrow(index_sequence_for_tpl{}); + }; + +} // namespace neo::core::_tuple_detail diff --git a/src/neo/core/tuple.hpp b/src/neo/core/tuple.hpp new file mode 100644 index 0000000..10c4bf5 --- /dev/null +++ b/src/neo/core/tuple.hpp @@ -0,0 +1,249 @@ +#pragma once + +#include "./tuple.detail.hpp" + +#include +#include +#include +#include + +#include + +namespace neo { + +// Tag used to select the piece-wise constructor for a tuple +struct tuple_construct_tag {}; +// Tag to select a tuple->tuple converting constructor +struct tuple_convert_tag {}; + +} // namespace neo + +namespace neo::core { + +/** + * @brief A core::tuple is like a full neo::tuple but provides a simpler interface + * upon which the more expressive interface is constructed. + */ +template +class tuple { +public: + using index_sequence = std::make_index_sequence; + + template + using nth_type = nonvoid_t>; + +private: + using boxes = _tuple_detail::boxes; + + NEO_NO_UNIQUE_ADDRESS boxes _boxes; + + template + using _nth_box = _tuple_detail::nth_box>; + +public: + tuple() = default; + + /** + * @brief Tuple per-element-converting constructor. + * + * @param tag A tag to select this constructor + * @param args... Arguments that will be converted to the tuple elements. + */ + template + constexpr explicit tuple(tuple_construct_tag, + Args&&... args) // + noexcept((nothrow_constructible_from, Args> and ...)) + : _boxes(std::in_place, NEO_FWD(args)...) {} + + /** + * @brief From-tuple converting constructor. Converts from another tuple-like + * object (using neo::get_nth) for each tuple element. + * + * @param tag The tag to select this constructor + * @param tpl The tuple-like object to construct from. Elements will be perfect-forwarded from + * this tuple + */ + template + constexpr explicit tuple(tuple_convert_tag, + Tpl&& tpl, + std::index_sequence) // + noexcept((nothrow_constructible_from, get_nth_t> and ...)) + : _boxes(std::in_place, get_nth(NEO_FWD(tpl))...) {} + + template + constexpr add_lvalue_reference_t> get() & noexcept { + auto& box = static_cast<_nth_box&>(_boxes); + return static_cast>>(box.get()); + } + + template + constexpr add_lvalue_reference_t> get() const& noexcept { + auto& box = static_cast&>(_boxes); + return static_cast>>(box.get()); + } + + template + constexpr add_rvalue_reference_t> get() && noexcept { + auto& box = static_cast<_nth_box&>(_boxes); + return static_cast>>(box.get()); + } + + template + constexpr add_rvalue_reference_t> get() const&& noexcept { + auto& box = static_cast&>(_boxes); + return static_cast>>(box.get()); + } + + bool operator==(tuple const&) const = default; + auto operator<=>(tuple const&) const = default; +}; + +// Specialization of an empty tuple +template <> +class tuple<> { +public: + using index_sequence = std::index_sequence<>; + + tuple() = default; + constexpr explicit tuple(tuple_construct_tag) noexcept {} + template + requires(not can_get_nth) + constexpr explicit tuple(tuple_convert_tag, Tpl&&, std::index_sequence<>) noexcept {} + + template + void get() = delete; + + bool operator==(tuple const&) const = default; + auto operator<=>(tuple const&) const = default; +}; + +// Specialization for a 1-element tuple +template +class tuple { + using Type = nonvoid_t; + NEO_NO_UNIQUE_ADDRESS object_t _value; + +public: + using index_sequence = std::index_sequence<0>; + + tuple() = default; + + template Arg> + constexpr explicit tuple(tuple_construct_tag, + Arg&& arg) // + noexcept(nothrow_constructible_from) + : _value(NEO_FWD(arg)) {} + + template + requires(can_get_nth) + constexpr explicit tuple(tuple_convert_tag, Tpl&& tpl, std::index_sequence<0>) noexcept( + nothrow_constructible_from>) + : _value(get_nth<0>(NEO_FWD(tpl))) {} + + template + requires(N == 0) + constexpr add_lvalue_reference_t get() & noexcept { + return static_cast>(_value); + } + + template + requires(N == 0) + constexpr add_const_reference_t get() const& noexcept { + return static_cast>(_value); + } + + template + requires(N == 0) + constexpr add_rvalue_reference_t get() && noexcept { + return static_cast>(_value); + } + + template + requires(N == 0) + constexpr add_rvalue_reference_t get() const&& noexcept { + return static_cast>(_value); + } + + bool operator==(tuple const&) const = default; + auto operator<=>(tuple const&) const = default; +}; + +// Specialization for a 2-element tuple +template +class tuple { + NEO_NO_UNIQUE_ADDRESS object_t _first; + NEO_NO_UNIQUE_ADDRESS object_t _second; + + using Tnv = nonvoid_t; + using Unv = nonvoid_t; + + template + using _type = conditional_t; + +public: + using index_sequence = std::index_sequence<0, 1>; + + tuple() = default; + + template Arg1, convertible_to Arg2> + constexpr explicit tuple(tuple_construct_tag, + Arg1&& arg1, + Arg2&& arg2) // + noexcept(nothrow_constructible_from and nothrow_constructible_from) + : _first(NEO_FWD(arg1)) + , _second(NEO_FWD(arg2)) {} + + template + requires(can_get_nth) + constexpr explicit tuple(tuple_convert_tag, Tpl&& tpl, std::index_sequence<0, 1>) noexcept( + nothrow_constructible_from> + and nothrow_constructible_from>) + : _first(get_nth<0>(NEO_FWD(tpl))) + , _second(get_nth<1>(NEO_FWD(tpl))) {} + + template + constexpr _type& get() & noexcept { + if constexpr (N) + return static_cast(_second); + else + return static_cast(_first); + } + + template + constexpr _type const& get() const& noexcept { + if constexpr (N) + return static_cast(_second); + else + return static_cast(_first); + } + + template + constexpr _type&& get() && noexcept { + if constexpr (N) + return static_cast(_second); + else + return static_cast(_first); + } + + template + constexpr _type const&& get() const&& noexcept { + if constexpr (N) + return static_cast(_second); + else + return static_cast(_first); + } + + bool operator==(tuple const&) const = default; + auto operator<=>(tuple const&) const = default; +}; + +} // namespace neo::core + +template +struct std::tuple_size> { + constexpr static inline std::size_t value = sizeof...(Ts); +}; + +template +struct std::tuple_element> + : neo::meta::tag, N>> {}; diff --git a/src/neo/coroutine.hpp b/src/neo/coroutine.hpp new file mode 100644 index 0000000..9ec0e84 --- /dev/null +++ b/src/neo/coroutine.hpp @@ -0,0 +1,19 @@ +#pragma once + +#include "./config-pp.hpp" + +#include + +#if defined __GNUC__ && (!defined(__clang__)) && __GNUC__ < 13 +// See: https://gcc.gnu.org/bugzilla/show_bug.cgi?id=99576 +#define NEO_GCC_Broken_Coroutines Enabled +#else +#define NEO_GCC_Broken_Coroutines Disabled +#endif + +#if defined __clang__ && __clang_major__ < 17 +// See: https://github.com/llvm/llvm-project/issues/61900 +#define NEO_Clang_Broken_Coroutines Enabled +#else +#define NEO_Clang_Broken_Coroutines Disabled +#endif diff --git a/src/neo/ct_optional.cpp b/src/neo/ct_optional.cpp new file mode 100644 index 0000000..dce2c83 --- /dev/null +++ b/src/neo/ct_optional.cpp @@ -0,0 +1,7 @@ +#include "./ct_optional.hpp" + +#include "./assert.hpp" + +void neo::_ct_optional_detail::terminate(const char* func) { + neo_assert(expects, false, "Attempted to access a null compile-time optional value.", func); +} diff --git a/src/neo/ct_optional.hpp b/src/neo/ct_optional.hpp new file mode 100644 index 0000000..e0f037e --- /dev/null +++ b/src/neo/ct_optional.hpp @@ -0,0 +1,97 @@ +#pragma once + +#include "./attrib.hpp" +#include "./concepts.hpp" +#include "./fwd.hpp" +#include "./like.hpp" +#include "./object_box.hpp" +#include "./unit.hpp" + +namespace neo { + +namespace _ct_optional_detail { + +[[noreturn]] void terminate(const char*); + +} // namespace _ct_optional_detail + +/** + * @brief A compile-time optional value. + * + * Unlike a regular std::optional, a ct_optional either does or does not hold a + * value, and this is fixed at compile-time. + * + * @tparam T + * @tparam HasValue + */ +template +class ct_optional { + using Stored = conditional_t, unit>; + + NEO_NO_UNIQUE_ADDRESS Stored _box; + + template + constexpr forward_like_t _get(S&& self) noexcept { + if constexpr (HasValue) { + return NEO_FWD(self)._box.get(); + } else { + _ct_optional_detail::terminate(__func__); + } + } + + struct emplace {}; + + template + requires HasValue // + constexpr ct_optional(emplace, Args&&... args) // + noexcept(std::is_nothrow_constructible_v) + : _box(T(NEO_FWD(args)...)) {} + + template + constexpr ct_optional(emplace, Args&&...) noexcept {} + +public: + using has_value_tag = std::bool_constant; + + constexpr ct_optional() + requires default_initializable + = default; + + template U> + explicit(not convertible_to) // + constexpr ct_optional(U&& arg) noexcept(nothrow_constructible_from) + : ct_optional(emplace{}, NEO_FWD(arg)) {} + + template + constexpr explicit ct_optional(std::in_place_t, Args&&... args) // + noexcept(nothrow_constructible_from) + : ct_optional(emplace{}, NEO_FWD(args)...) {} + + constexpr ct_optional(ct_optional const&) // + requires copy_constructible + = default; + + constexpr ct_optional(ct_optional&&) // + requires move_constructible + = default; + + constexpr ct_optional& operator=(const ct_optional&) // + requires copy_assignable + = default; + + constexpr ct_optional& operator=(ct_optional&&) // + requires move_assignable + = default; + + constexpr bool has_value() const noexcept { return HasValue; } + + constexpr T& operator*() & noexcept { return _get(*this); } + constexpr const T& operator*() const& noexcept { return _get(*this); } + constexpr T&& operator*() && noexcept { return _get(NEO_MOVE(*this)); } + constexpr const T&& operator*() const&& noexcept { return _get(NEO_MOVE(*this)); } + + constexpr auto operator->() noexcept { return neo::addressof(**this); } + constexpr auto operator->() const noexcept { return neo::addressof(**this); } +}; + +} // namespace neo diff --git a/src/neo/ct_optional.test.cpp b/src/neo/ct_optional.test.cpp new file mode 100644 index 0000000..af85e68 --- /dev/null +++ b/src/neo/ct_optional.test.cpp @@ -0,0 +1,28 @@ +#include "./ct_optional.hpp" +#include "neo/attrib.hpp" +#include "neo/type_traits.hpp" + +#include + +TEST_CASE("Create an optional") { + neo::ct_optional v = 12; + CHECK(v.has_value()); + CHECK(*v == 12); + v = 84; + CHECK(*v == 84); + + neo::ct_optional s; + s = "I am a string"; + CHECK(*s == "I am a string"); + + // std::string s1 = *std::move(s); + // CHECK(s->empty()); + + neo::ct_optional, true> uptr = std::make_unique(12); + CHECK(**uptr == 12); + auto taken = *std::move(uptr); + static_assert(not std::copyable, true>>); + static_assert(not std::copyable, false>>); + static_assert(not std::copy_constructible, false>>); + static_assert(not std::is_copy_assignable_v, false>>); +} 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 + namespace neo { +#if NEO_HAS_BUILTIN(__add_rvalue_reference) +template +using add_rref_t = __add_rvalue_reference(T); +#define _neoDeclVal(...) (((__add_rvalue_reference(__VA_ARGS__)(*)())(void*)(nullptr))()) +#else template using add_rref_t = T&&; +#define _neoDeclVal(...) (((::neo::add_rref_t<__VA_ARGS__>(*)())(void*)(nullptr))()) +#endif } // namespace neo /** * @brief Equivalent of std::declval(), 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/detail/special_mems.ipp b/src/neo/detail/special_mems.ipp new file mode 100644 index 0000000..c95f7e9 --- /dev/null +++ b/src/neo/detail/special_mems.ipp @@ -0,0 +1,4102 @@ +// clang-format off +constexpr inline auto U = special_member_kind::undeclared; +constexpr inline auto F = special_member_kind::defaulted; +constexpr inline auto D = special_member_kind::deleted; +constexpr inline auto N = special_member_kind::nontrivial; +template using CR=const T&; +template<>struct S{}; +template<>struct S{S()=default;}; +template<>struct S{S()=delete;}; +template<>struct S{S();}; +template<>struct S{~S()=default;}; +template<>struct S{S()=default;~S()=default;}; +template<>struct S{S()=delete;~S()=default;}; +template<>struct S{S();~S()=default;}; +template<>struct S{~S()=delete;}; +template<>struct S{S()=default;~S()=delete;}; +template<>struct S{S()=delete;~S()=delete;}; +template<>struct S{S();~S()=delete;}; +template<>struct S{~S();}; +template<>struct S{S()=default;~S();}; +template<>struct S{S()=delete;~S();}; +template<>struct S{S();~S();}; +template<>struct S{S(CR)=default;}; +template<>struct S{S()=default;S(CR)=default;}; +template<>struct S{S()=delete;S(CR)=default;}; +template<>struct S{S();S(CR)=default;}; +template<>struct S{~S()=default;S(CR)=default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;}; +template<>struct S{S();~S()=default;S(CR)=default;}; +template<>struct S{~S()=delete;S(CR)=default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;}; +template<>struct S{S();~S()=delete;S(CR)=default;}; +template<>struct S{~S();S(CR)=default;}; +template<>struct S{S()=default;~S();S(CR)=default;}; +template<>struct S{S()=delete;~S();S(CR)=default;}; +template<>struct S{S();~S();S(CR)=default;}; +template<>struct S{S(CR)=delete;}; +template<>struct S{S()=default;S(CR)=delete;}; +template<>struct S{S()=delete;S(CR)=delete;}; +template<>struct S{S();S(CR)=delete;}; +template<>struct S{~S()=default;S(CR)=delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;}; +template<>struct S{~S()=delete;S(CR)=delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;}; +template<>struct S{~S();S(CR)=delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;}; +template<>struct S{S();~S();S(CR)=delete;}; +template<>struct S{S(CR);}; +template<>struct S{S()=default;S(CR);}; +template<>struct S{S()=delete;S(CR);}; +template<>struct S{S();S(CR);}; +template<>struct S{~S()=default;S(CR);}; +template<>struct S{S()=default;~S()=default;S(CR);}; +template<>struct S{S()=delete;~S()=default;S(CR);}; +template<>struct S{S();~S()=default;S(CR);}; +template<>struct S{~S()=delete;S(CR);}; +template<>struct S{S()=default;~S()=delete;S(CR);}; +template<>struct S{S()=delete;~S()=delete;S(CR);}; +template<>struct S{S();~S()=delete;S(CR);}; +template<>struct S{~S();S(CR);}; +template<>struct S{S()=default;~S();S(CR);}; +template<>struct S{S()=delete;~S();S(CR);}; +template<>struct S{S();~S();S(CR);}; +template<>struct S{S(S&&)=default;}; +template<>struct S{S()=default;S(S&&)=default;}; +template<>struct S{S()=delete;S(S&&)=default;}; +template<>struct S{S();S(S&&)=default;}; +template<>struct S{~S()=default;S(S&&)=default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;}; +template<>struct S{S();~S()=default;S(S&&)=default;}; +template<>struct S{~S()=delete;S(S&&)=default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;}; +template<>struct S{S();~S()=delete;S(S&&)=default;}; +template<>struct S{~S();S(S&&)=default;}; +template<>struct S{S()=default;~S();S(S&&)=default;}; +template<>struct S{S()=delete;~S();S(S&&)=default;}; +template<>struct S{S();~S();S(S&&)=default;}; +template<>struct S{S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;}; +template<>struct S{S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;}; +template<>struct S{S(CR);S(S&&)=default;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;}; +template<>struct S{S();S(CR);S(S&&)=default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;}; +template<>struct S{~S();S(CR);S(S&&)=default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;}; +template<>struct S{S(S&&)=delete;}; +template<>struct S{S()=default;S(S&&)=delete;}; +template<>struct S{S()=delete;S(S&&)=delete;}; +template<>struct S{S();S(S&&)=delete;}; +template<>struct S{~S()=default;S(S&&)=delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;}; +template<>struct S{S();~S()=default;S(S&&)=delete;}; +template<>struct S{~S()=delete;S(S&&)=delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;}; +template<>struct S{~S();S(S&&)=delete;}; +template<>struct S{S()=default;~S();S(S&&)=delete;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;}; +template<>struct S{S();~S();S(S&&)=delete;}; +template<>struct S{S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;}; +template<>struct S{S(CR);S(S&&)=delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;}; +template<>struct S{S();S(CR);S(S&&)=delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;}; +template<>struct S{~S();S(CR);S(S&&)=delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;}; +template<>struct S{S(S&&);}; +template<>struct S{S()=default;S(S&&);}; +template<>struct S{S()=delete;S(S&&);}; +template<>struct S{S();S(S&&);}; +template<>struct S{~S()=default;S(S&&);}; +template<>struct S{S()=default;~S()=default;S(S&&);}; +template<>struct S{S()=delete;~S()=default;S(S&&);}; +template<>struct S{S();~S()=default;S(S&&);}; +template<>struct S{~S()=delete;S(S&&);}; +template<>struct S{S()=default;~S()=delete;S(S&&);}; +template<>struct S{S()=delete;~S()=delete;S(S&&);}; +template<>struct S{S();~S()=delete;S(S&&);}; +template<>struct S{~S();S(S&&);}; +template<>struct S{S()=default;~S();S(S&&);}; +template<>struct S{S()=delete;~S();S(S&&);}; +template<>struct S{S();~S();S(S&&);}; +template<>struct S{S(CR)=default;S(S&&);}; +template<>struct S{S()=default;S(CR)=default;S(S&&);}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);}; +template<>struct S{S();S(CR)=default;S(S&&);}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);}; +template<>struct S{~S();S(CR)=default;S(S&&);}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);}; +template<>struct S{S();~S();S(CR)=default;S(S&&);}; +template<>struct S{S(CR)=delete;S(S&&);}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);}; +template<>struct S{S();S(CR)=delete;S(S&&);}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);}; +template<>struct S{~S();S(CR)=delete;S(S&&);}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);}; +template<>struct S{S(CR);S(S&&);}; +template<>struct S{S()=default;S(CR);S(S&&);}; +template<>struct S{S()=delete;S(CR);S(S&&);}; +template<>struct S{S();S(CR);S(S&&);}; +template<>struct S{~S()=default;S(CR);S(S&&);}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);}; +template<>struct S{S();~S()=default;S(CR);S(S&&);}; +template<>struct S{~S()=delete;S(CR);S(S&&);}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);}; +template<>struct S{~S();S(CR);S(S&&);}; +template<>struct S{S()=default;~S();S(CR);S(S&&);}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);}; +template<>struct S{S();~S();S(CR);S(S&&);}; +template<>struct S{S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S();S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =default;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;}; +template<>struct S{S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =default;}; +template<>struct S{S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =delete;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;}; +template<>struct S{S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =delete;}; +template<>struct S{S&operator=(const S&)&;}; +template<>struct S{S()=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S&operator=(const S&)&;}; +template<>struct S{S();S&operator=(const S&)&;}; +template<>struct S{~S()=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)&;}; +template<>struct S{~S();S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)&;}; +template<>struct S{S();~S();S&operator=(const S&)&;}; +template<>struct S{S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)&;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)&;}; +template<>struct S{S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)&;}; +template<>struct S{S();S(CR);S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)&;}; +template<>struct S{~S();S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)&;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)&;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;}; +template<>struct S{S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)&;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)&;}; +template<>struct S{S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(S&&)& =default;}; +template<>struct S{S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =default;}; +template<>struct S{S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =default;}; +template<>struct S{S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =default;}; +template<>struct S{S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(S&&)& =delete;}; +template<>struct S{S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)& =delete;}; +template<>struct S{S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)& =delete;}; +template<>struct S{S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)& =delete;}; +template<>struct S{S&operator=(S&&)&;}; +template<>struct S{S()=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S&operator=(S&&)&;}; +template<>struct S{S();S&operator=(S&&)&;}; +template<>struct S{~S()=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S&operator=(S&&)&;}; +template<>struct S{~S();S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S&operator=(S&&)&;}; +template<>struct S{S();~S();S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(S&&)&;}; +template<>struct S{S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S&operator=(S&&)&;}; +template<>struct S{S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(S&&)&;}; +template<>struct S{S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&);S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(S&&)&;}; +template<>struct S{S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =default;S&operator=(S&&)&;}; +template<>struct S{S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)& =delete;S&operator=(S&&)&;}; +template<>struct S{S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=default;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&)=delete;S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=default;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR)=delete;S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=default;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S()=delete;S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=default;~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S()=delete;~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; +template<>struct S{S();~S();S(CR);S(S&&);S&operator=(const S&)&;S&operator=(S&&)&;}; \ No newline at end of file diff --git a/src/neo/emplacement.hpp b/src/neo/emplacement.hpp new file mode 100644 index 0000000..85c942d --- /dev/null +++ b/src/neo/emplacement.hpp @@ -0,0 +1,27 @@ +#pragma once + +#include "./fwd.hpp" + +#include + +namespace neo { + +template + requires requires(void* p, Args&&... args) { ::new (p) T(NEO_FWD(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 +[[deprecated("Use std::destroy_at")]] constexpr void destroy_at(T* addr) { + std::destroy_at(addr); +} + +#define NEO_CONSTRUCT_AT ::neo::construct_at + +// No compiler lets this "just work" +#define NEO_DESTROY_AT (::neo::destroy_at) + +} // namespace neo diff --git a/src/neo/event.hpp b/src/neo/event.hpp index 5fb8830..80becec 100644 --- a/src/neo/event.hpp +++ b/src/neo/event.hpp @@ -4,7 +4,6 @@ #include "./function_traits.hpp" #include "./fwd.hpp" #include "./invoke.hpp" -#include "./opt_ref.hpp" #include "./optional.hpp" #include "./scope.hpp" #include "./tag.hpp" @@ -38,11 +37,11 @@ namespace event_detail { /// The top-most subscriber for events of type T, or null if no one is subscribed template -thread_local opt_ref> tl_tail_listener; +thread_local optional&> tl_tail_listener; /// The currently executing event handler for the given type 'T' template -thread_local opt_ref> tl_currently_running_handler; +thread_local optional&> tl_currently_running_handler; // helper for emit_as_t template @@ -117,9 +116,9 @@ emit_result_t get_default_emit_result(const E& ev) template emit_result_t get_default_emit_result(const E& ev) requires requires { - requires !requires { ev.default_emit_result(); }; - requires default_initializable>; - } + requires !requires { ev.default_emit_result(); }; + requires default_initializable>; + } { return emit_result_t(); } @@ -131,7 +130,7 @@ emit_result_t get_default_emit_result(const E& ev) * @tparam T The type of the event that is being listened for */ template -opt_ref> get_event_subscriber() noexcept { +optional&> get_event_subscriber() noexcept { return event_detail::tl_tail_listener; } @@ -188,19 +187,20 @@ class scoped_listener { } // Keep a reference to the prior handler in the thread-local stack - opt_ref> _prev_ref = std::exchange(event_detail::tl_tail_listener, *this); + scoped_listener* _prev_ref + = std::exchange(event_detail::tl_tail_listener, *this).as_pointer(); public: scoped_listener() = default; virtual ~scoped_listener() { neo_assert(expects, - event_detail::tl_tail_listener.pointer() == this, + event_detail::tl_tail_listener.as_pointer() == this, "neo::subscribe() objects are being destructed out-of-order, which is illegal.", this, - event_detail::tl_tail_listener.pointer()); + event_detail::tl_tail_listener.as_pointer()); // Restore the prior event handler - event_detail::tl_tail_listener = _prev_ref; + event_detail::tl_tail_listener = *_prev_ref; } // We are immobile @@ -213,8 +213,8 @@ class scoped_listener { out.type("neo::scoped_listener<...>"); } if (self) { - bool is_active = self == event_detail::tl_currently_running_handler.pointer(); - bool is_tail = self == event_detail::tl_tail_listener.pointer(); + bool is_active = self == event_detail::tl_currently_running_handler.as_pointer(); + bool is_tail = self == event_detail::tl_tail_listener.as_pointer(); out.bracket_value("active={}, tail={}", is_active, is_tail); } } 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 + namespace neo::move_detail { template @@ -17,8 +19,8 @@ struct strip_type { 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::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 +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace neo::_get { + +// Match an opt-ref like type of unspecified referred-to type +template +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; + requires semiregular; +}; + +// Match an opt-ref-like whose dereference operator returns the given type +template +concept opt_ref_to = opt_ref_like and requires(const OptRef ref) { + { *ref } -> neo::weak_same_as; +}; + +// 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 +constexpr bool sfinae_mask = true; + +template +constexpr bool sfinae_mask_n = true; + +template +constexpr bool sfinae_mask, Alt> = (weak_same_as || ...); + +template +constexpr bool sfinae_mask, Alt> = (weak_same_as || ...); + +template +constexpr bool sfinae_mask_n, N> = sizeof...(Ts) > N; + +template +constexpr bool sfinae_mask_n, N> = sizeof...(Ts) > N; + +template +constexpr bool sfinae_mask_n, N> = N < Len; + +template +constexpr bool sfinae_mask_n, N> = N < 2; + +template +void try_get() = delete; + +template +void try_get() = delete; + +template +void get() = delete; + +template +void get() = delete; + +namespace declared { +// Does `T` have a `nth_type<>` member alias template? +template +concept has_member_template_nth_type = requires { typename T::template nth_type; }; +// Does `T` have a valid std::tuple_element_t? +template +concept has_std_tuple_element + = sfinae_mask_n and requires { typename std::tuple_element_t; }; +// Does `T` have a valid std::variant_alternative_t? +template +concept has_std_variant_alternative + = sfinae_mask_n and requires { typename std::variant_alternative_t; }; + +template +struct try_var_alt {}; + +template +struct try_tpl_elem { + template + using f = try_var_alt>::template f; +}; + +template +struct try_nth_type { + template + using f = try_tpl_elem>::template f; +}; + +template <> +struct try_nth_type { + template + using f = typename T::template nth_type; +}; + +template <> +struct try_tpl_elem { + template + using f = std::tuple_element_t; +}; + +template <> +struct try_var_alt { + template + using f = std::variant_alternative_t; +}; + +template +using nth = try_nth_type>::template f; +} // namespace declared + +template +using nth_type_t = declared::nth, N>; + +template +concept has_nth_type = requires { typename nth_type_t; }; + +template +using forward_nth_type_t = forward_like_tuple_t>; + +template +concept has_member_try_get_nth = requires(T&& var) { + { var.template try_get() } noexcept -> opt_ref_to>; +}; + +template +concept has_free_try_get_nth = requires(T&& var) { + { try_get(var) } noexcept -> opt_ref_to>; +}; + +template +concept has_free_get_if_nth = requires(T&& var) { + requires sfinae_mask_n, N>; + { get_if(NEO_ADDRESSOF(var)) } noexcept -> opt_ref_to>; +}; + +template +concept has_any_try_get_nth_backend + = has_member_try_get_nth or has_free_try_get_nth or has_free_get_if_nth; + +template +concept has_member_get_nth = requires(T&& var) { + { NEO_FWD(var).template get() } noexcept -> weak_same_as>; +}; + +template +concept has_free_get_nth = sfinae_mask_n, N> and requires(T&& var) { + { get(NEO_FWD(var)) } noexcept -> weak_same_as>; +}; + +template +concept has_any_direct_get_nth_backend = not has_any_try_get_nth_backend + and (has_free_get_nth or has_member_get_nth); + +constexpr inline std::size_t invalid_index = ~std::size_t(0); + +template +constexpr std::size_t lookup_v = invalid_index; + +template + requires((weak_same_as + ...) == 1) +constexpr std::size_t lookup_v, Alt> = meta::find_type_v; + +template , Alt>> +concept can_try_get_alt = N != invalid_index and has_any_try_get_nth_backend; + +template , Alt>> +concept can_direct_get_alt + = N != invalid_index and not can_try_get_alt and has_any_direct_get_nth_backend; + +/* +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 +struct try_nth { + template <_get::has_any_try_get_nth_backend T> + NEO_ALWAYS_INLINE constexpr opt_ref_like auto operator()(T&& obj) const noexcept { + if constexpr (has_member_try_get_nth) { + return obj.template try_get(); + } else if constexpr (has_free_try_get_nth) { + return try_get(obj); + } else { + return get_if(NEO_ADDRESSOF(obj)); + } + } +}; + +template +struct nth { + template T> + NEO_ALWAYS_INLINE constexpr forward_nth_type_t operator()(T&& obj) const { + auto oref = try_nth{}(obj); + if (not oref) { + throw std::bad_variant_access(); + } else { + return static_cast>(*oref); + } + } + + template T> + NEO_ALWAYS_INLINE constexpr forward_nth_type_t operator()(T&& obj) const { + if constexpr (has_member_get_nth) { + return NEO_FWD(obj).template get(); + } else { + return get(NEO_FWD(obj)); + } + } +}; + +template +struct try_as { + template T> + NEO_ALWAYS_INLINE constexpr opt_ref_like auto operator()(T&& obj) const noexcept { + constexpr auto N = lookup_v, Alt>; + return try_nth{}(NEO_FWD(obj)); + } +}; + +template +struct as { + template T> + NEO_ALWAYS_INLINE constexpr forward_like_tuple_t operator()(T&& obj) const { + auto opt = try_as{}(obj); + if (not opt) { + throw std::bad_variant_access(); + } else { + return static_cast>(*opt); + } + } + + template T> + NEO_ALWAYS_INLINE constexpr forward_like_tuple_t operator()(T&& obj) const { + constexpr auto N = lookup_v, Alt>; + return nth{}(NEO_FWD(obj)); + } +}; + +template +struct holds_alternative { + static constexpr inline try_as try_it = {}; + + template T> + NEO_ALWAYS_INLINE constexpr bool operator()(const T& obj) const noexcept { + return static_cast(try_it(obj)); + } +}; + +template +struct holds_alternative_n { + static constexpr inline try_nth try_it = {}; + + template T> + NEO_ALWAYS_INLINE constexpr bool operator()(const T& obj) const noexcept { + return static_cast(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 +#include +#include + +#include +#include + +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 +constexpr inline auto try_get_nth = _get::try_nth{}; + +/** + * @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 +constexpr inline auto get_nth = _get::nth{}; + +/** + * @brief Attempt to obtain a given alternative from a variant-like object. + * + * @tparam Alt The type to attempt to obtain from the variant. + */ +template +constexpr inline auto try_get_as = _get::try_as{}; + +/** + * @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 +constexpr inline auto get_as = _get::as{}; + +/** + * @brief The result of try_get_nth with the given type+index + */ +template +using try_get_nth_t = decltype(try_get_nth(NEO_DECLVAL(V))); + +/** + * @brief The result of get_nth with the given type+index + */ +template +using get_nth_t = decltype(get_nth(NEO_DECLVAL(V))); + +/** + * @brief The result type of try_get_as with the given type+index + */ +template +using try_get_as_t = decltype(try_get_as(NEO_DECLVAL(V))); + +/** + * @brief The result type of get_as with the given type+index + */ +template +using get_as_t = decltype(get_as(NEO_DECLVAL(V))); + +template +concept can_get_nth = requires(Tpl&& tpl) { get_nth(NEO_FWD(tpl)); }; + +template +concept can_get_as = requires(T&& obj) { get_as(NEO_FWD(obj)); }; + +template +constexpr inline auto holds_alternative = _get::holds_alternative{}; + +template +constexpr inline auto holds_alternative_n = _get::holds_alternative_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 + +#include + +#include +#include +#include +#include + +static_assert(neo::_get::has_nth_type, 0>); +static_assert(not neo::_get::has_nth_type, 1>); +static_assert(neo::_get::has_nth_type, 0>); +static_assert(not neo::_get::has_nth_type, 1>); +static_assert(not neo::_get::has_nth_type, 0>); +static_assert(not neo::_get::has_nth_type, 1>); + +static_assert(neo::_get::has_free_get_if_nth, 0>); +static_assert(not neo::_get::has_free_get_if_nth, 1>); + +static_assert(std::same_as, 0>, int*>); +static_assert(std::same_as const, 0>, int const*>); +static_assert(std::same_as const&, 0>, int const*>); +static_assert(std::same_as&&, 0>, int*>); +static_assert(std::same_as&&, 0>, int&&>); +static_assert(std::same_as&, 0>, int&>); +static_assert(std::same_as const&, 0>, const int&>); +static_assert(std::same_as, 0>, int&&>); + +static_assert(std::same_as, int>, int*>); +static_assert(std::same_as const, int>, int const*>); +static_assert(std::same_as const&, int>, int const*>); +static_assert(std::same_as&&, int>, int*>); +static_assert(std::same_as&&, int>, int&&>); +static_assert(std::same_as&, int>, int&>); +static_assert(std::same_as const&, int>, const int&>); +static_assert(std::same_as, int>, int&&>); + +static_assert(std::same_as&&, 0>, int&&>); +static_assert(std::same_as&, 0>, int&>); +static_assert(std::same_as const&, 0>, const int&>); +static_assert(std::same_as, 0>, int&&>); +static_assert(std::same_as&&, int>, int&&>); +static_assert(std::same_as&, int>, int&>); +static_assert(std::same_as const&, int>, const int&>); +static_assert(std::same_as, int>, int&&>); + +TEST_CASE("Get Nth from std::tuple<>") { + STATIC_REQUIRE(neo::can_get_nth, 0>); + STATIC_REQUIRE(neo::can_get_nth&, 0>); + STATIC_REQUIRE(neo::can_get_nth const&, 0>); + STATIC_REQUIRE(neo::can_get_nth&&, 0>); + STATIC_REQUIRE(neo::can_get_nth const&&, 0>); + STATIC_REQUIRE(not neo::can_get_nth, 1>); + STATIC_REQUIRE(not neo::can_get_nth&, 1>); + STATIC_REQUIRE(not neo::can_get_nth const&, 1>); + STATIC_REQUIRE(not neo::can_get_nth&&, 1>); + STATIC_REQUIRE(not neo::can_get_nth const&&, 1>); + + STATIC_REQUIRE(std::same_as, 0>, int&&>); + STATIC_REQUIRE(std::same_as, 0>, int&>); + STATIC_REQUIRE(std::same_as const&, 0>, int&>); + STATIC_REQUIRE(std::same_as const&, 0>, const int&>); + STATIC_REQUIRE(std::same_as&, 0>, const int&>); + STATIC_REQUIRE(std::same_as&&, 0>, const int&>); + STATIC_REQUIRE(std::same_as&&, 0>, int&&>); + STATIC_REQUIRE(std::same_as&, 0>, int&>); +} + +TEST_CASE("Can get T from a std::tuple<>") { + STATIC_REQUIRE(neo::can_get_as, int>); + STATIC_REQUIRE(neo::can_get_as&, int>); + STATIC_REQUIRE(neo::can_get_as const&, int>); + STATIC_REQUIRE(neo::can_get_as&&, int>); + STATIC_REQUIRE(neo::can_get_as const&&, int>); + STATIC_REQUIRE(not neo::can_get_as, char>); + STATIC_REQUIRE(not neo::can_get_as&, char>); + STATIC_REQUIRE(not neo::can_get_as const&, char>); + STATIC_REQUIRE(not neo::can_get_as&&, char>); + STATIC_REQUIRE(not neo::can_get_as const&&, char>); + + // The type T must be exactly an alternative, not cvr allowed: + STATIC_REQUIRE(not neo::can_get_as, int&>); + STATIC_REQUIRE(not neo::can_get_as&, int&>); + STATIC_REQUIRE(not neo::can_get_as const&, int&>); + STATIC_REQUIRE(not neo::can_get_as&&, int&>); + STATIC_REQUIRE(not neo::can_get_as const&&, int&>); + + // Getting from a tuple applies the cvref qualifiers: + STATIC_REQUIRE(std::same_as, int>, int&&>); + STATIC_REQUIRE(std::same_as&, int>, int&>); + STATIC_REQUIRE(std::same_as const&, int>, const int&>); + STATIC_REQUIRE(std::same_as&&, int>, int&&>); + STATIC_REQUIRE(std::same_as const&&, int>, const int&&>); + + // Reference collapsing: + STATIC_REQUIRE(std::same_as, int&>, int&>); + STATIC_REQUIRE(std::same_as&, int&>, int&>); + STATIC_REQUIRE(std::same_as const&, int&>, int&>); + STATIC_REQUIRE(std::same_as&&, int&>, int&>); + STATIC_REQUIRE(std::same_as const&&, int&>, int&>); +} + +TEST_CASE("Get Nth from std::variant<>") { + STATIC_REQUIRE(neo::can_get_nth, 0>); + STATIC_REQUIRE(neo::can_get_nth&, 0>); + STATIC_REQUIRE(neo::can_get_nth const&, 0>); + STATIC_REQUIRE(neo::can_get_nth&&, 0>); + STATIC_REQUIRE(neo::can_get_nth const&&, 0>); + STATIC_REQUIRE(not neo::can_get_nth, 1>); + STATIC_REQUIRE(not neo::can_get_nth&, 1>); + STATIC_REQUIRE(not neo::can_get_nth const&, 1>); + STATIC_REQUIRE(not neo::can_get_nth&&, 1>); + STATIC_REQUIRE(not neo::can_get_nth const&&, 1>); +} + +TEST_CASE("Get T from std::variant<>") { + STATIC_REQUIRE(neo::can_get_as, int>); + STATIC_REQUIRE(neo::can_get_as&, int>); + STATIC_REQUIRE(neo::can_get_as const&, int>); + STATIC_REQUIRE(neo::can_get_as&&, int>); + STATIC_REQUIRE(neo::can_get_as const&&, int>); + STATIC_REQUIRE(not neo::can_get_as, char>); + STATIC_REQUIRE(not neo::can_get_as&, char>); + STATIC_REQUIRE(not neo::can_get_as const&, char>); + STATIC_REQUIRE(not neo::can_get_as&&, char>); + STATIC_REQUIRE(not neo::can_get_as const&&, char>); + + // The type T must be exactly an alternative, no cvr allowed: + STATIC_REQUIRE(not neo::can_get_as, int&>); + STATIC_REQUIRE(not neo::can_get_as&, int&>); + STATIC_REQUIRE(not neo::can_get_as const&, int&>); + STATIC_REQUIRE(not neo::can_get_as&&, int&>); + STATIC_REQUIRE(not neo::can_get_as const&&, int&>); + + // Getting from a variant applies the cvref qualifiers: + STATIC_REQUIRE(std::same_as, int>, int&&>); + STATIC_REQUIRE(std::same_as&, int>, int&>); + STATIC_REQUIRE(std::same_as const&, int>, const int&>); + STATIC_REQUIRE(std::same_as&&, int>, int&&>); + STATIC_REQUIRE(std::same_as const&&, int>, const int&&>); +} + +TEST_CASE("Get Nth from std::pair") { + STATIC_REQUIRE(neo::can_get_nth, 0>); + STATIC_REQUIRE(neo::can_get_nth, 1>); + STATIC_REQUIRE(not neo::can_get_nth, 2>); + + STATIC_REQUIRE(std::same_as, 1>, int&&>); + STATIC_REQUIRE(std::same_as, 1>, int&>); + STATIC_REQUIRE(std::same_as const&, 1>, int&>); + STATIC_REQUIRE(std::same_as const&, 1>, const int&>); + STATIC_REQUIRE(std::same_as&, 1>, const int&>); + STATIC_REQUIRE(std::same_as&&, 1>, const int&>); + STATIC_REQUIRE(std::same_as&&, 1>, int&&>); + STATIC_REQUIRE(std::same_as&, 1>, int&>); +} + +TEST_CASE("Can get T from a std::pair<>") { + STATIC_REQUIRE(neo::can_get_as, int>); + STATIC_REQUIRE(neo::can_get_as&, int>); + STATIC_REQUIRE(neo::can_get_as const&, int>); + STATIC_REQUIRE(neo::can_get_as&&, int>); + STATIC_REQUIRE(neo::can_get_as const&&, int>); + STATIC_REQUIRE(not neo::can_get_as, double>); + STATIC_REQUIRE(not neo::can_get_as&, double>); + STATIC_REQUIRE(not neo::can_get_as const&, double>); + STATIC_REQUIRE(not neo::can_get_as&&, double>); + STATIC_REQUIRE(not neo::can_get_as const&&, double>); + + // The type T must be exactly an alternative, no cvr allowed: + STATIC_REQUIRE(not neo::can_get_as, int&>); + STATIC_REQUIRE(not neo::can_get_as&, int&>); + STATIC_REQUIRE(not neo::can_get_as const&, int&>); + STATIC_REQUIRE(not neo::can_get_as&&, int&>); + STATIC_REQUIRE(not neo::can_get_as const&&, int&>); + + // Getting from a pair applies the cvref qualifiers: + STATIC_REQUIRE(std::same_as, int>, int&&>); + STATIC_REQUIRE(std::same_as&, int>, int&>); + STATIC_REQUIRE(std::same_as const&, int>, const int&>); + STATIC_REQUIRE(std::same_as&&, int>, int&&>); + STATIC_REQUIRE(std::same_as const&&, int>, const int&&>); + + // Reference collapsing: + STATIC_REQUIRE(std::same_as, int&>, int&>); + STATIC_REQUIRE(std::same_as&, int&>, int&>); + STATIC_REQUIRE(std::same_as const&, int&>, int&>); + STATIC_REQUIRE(std::same_as&&, int&>, int&>); + STATIC_REQUIRE(std::same_as const&&, int&>, int&>); +} + +TEST_CASE("Get from std::array") { + using array = std::array; + STATIC_REQUIRE(neo::can_get_nth); + STATIC_REQUIRE(neo::can_get_nth); + STATIC_REQUIRE(not neo::can_get_nth); +} + +struct invalid_getter { + template + using nth_type = int; + + template + constexpr int const& get() & noexcept; + template + constexpr int const& get() const& noexcept; + + template + constexpr int const& get() && noexcept; + template + constexpr int const& get() const&& noexcept; +}; + +struct invalid_ref_getter { + template + using nth_type = int&; + + // All bad: The get should always return `int&` + template + constexpr int const& get() & noexcept; + template + constexpr int const& get() const& noexcept; + template + constexpr int const& get() && noexcept; + template + constexpr int const& get() const&& noexcept; +}; + +struct invalid_ref_getter_v2 { + template + using nth_type = int&; + + // Okay: The getters return ref-to-mutable + template + constexpr int& get() & noexcept; + template + constexpr int& get() const& noexcept; + // Bad: We should not forward rvalue-refs + template + constexpr int&& get() && noexcept; + template + 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); + // Okay: The const `get` overload does the correct thing + STATIC_REQUIRE(neo::can_get_nth); + + // Bad: The rvalue-getter returns an lvalue reference + STATIC_REQUIRE_FALSE(neo::can_get_nth); + // Bad: The const&& `get` overload does nto return an value-ref-to-const + STATIC_REQUIRE_FALSE(neo::can_get_nth); + + STATIC_REQUIRE_FALSE(neo::can_get_nth); + STATIC_REQUIRE_FALSE(neo::can_get_nth); + STATIC_REQUIRE_FALSE(neo::can_get_nth); + STATIC_REQUIRE_FALSE(neo::can_get_nth); + + STATIC_REQUIRE(neo::can_get_nth); + STATIC_REQUIRE(neo::can_get_nth); + STATIC_REQUIRE_FALSE(neo::can_get_nth); + STATIC_REQUIRE_FALSE(neo::can_get_nth); +} + +neo::testing::cx_test_case TestHoldsAlternative = [](auto check) consteval { + std::variant var; + check(neo::holds_alternative(var)); + check(not neo::holds_alternative(var)); + check(neo::holds_alternative_n<0>(var)); + check(not neo::holds_alternative_n<1>(var)); +}; diff --git a/src/neo/immediate.hpp b/src/neo/immediate.hpp index 9cf8a74..6247fd1 100644 --- a/src/neo/immediate.hpp +++ b/src/neo/immediate.hpp @@ -5,6 +5,7 @@ #include "./fwd.hpp" #include "./optional.hpp" #include "./type_traits.hpp" +#include "neo/attrib.hpp" #include #include @@ -54,18 +55,18 @@ struct immediate_promise_base { template struct immediate_promise : immediate_promise_base { - nano_opt_storage _value; + storage_for _value; auto get_return_object() noexcept { return defer_convert{*this}; } template U> void return_value(U&& v) noexcept(noexcept(T(NEO_FWD(v)))) { - new (neo::addressof(_value.value)) T(NEO_FWD(v)); + _value.construct(NEO_FWD(v)); } - ~immediate_promise() { _value.value.~T(); } + ~immediate_promise() { _value.destroy(); } - T& value() noexcept { return _value.value; } + T& value() noexcept { return _value.get(); } }; template <> @@ -189,7 +190,7 @@ class immediate { template explicit immediate(const T&) -> immediate; -explicit immediate()->immediate; +explicit immediate() -> immediate; template constexpr imm_detail::defer_convert::operator immediate() const noexcept { 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 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 +struct pick_invoker_1; + +template <> +struct pick_invoker_1 { + // Invocable is not a member pointer, so defer to the regular calling semantics + template + using f = call_invoker; +}; + +template <> +struct pick_invoker_1 { + // Invocable is a pointer-to-member. + template + using f = conditional_t, + // Invoke as a member function + memfun_invoker, + // "Invoke" as member object + memobj_invoker>; +}; + template > -using pick_invoker_t = conditional_t< - not neo_is_member_pointer(D), - call_invoker, - conditional_t>; +using pick_invoker_t = pick_invoker_1>::template f; } // 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 +#include "./attrib.hpp" +#include "./type_traits.hpp" namespace neo { namespace like_detail { -template -struct conditional { - template - using eval = F; -}; +template +struct forward_like_impl; template <> -struct conditional { - template - using eval = T; -}; +struct forward_like_impl { + template + using merge = add_lvalue_reference_t>>; -template -concept similar = std::is_same_v, std::remove_cvref_t>; + template + using tuple = add_lvalue_reference_t>; -template -struct copy_ref { - using type = Onto; + template + using language = add_lvalue_reference_t>; }; -template -struct copy_ref { - using type = Onto&&; -}; +template <> +struct forward_like_impl { + template + using merge = add_rvalue_reference_t>>; + + template + using tuple = add_rvalue_reference_t>; -template -struct copy_ref { - using type = Onto&; + template + using language = add_lvalue_reference_t>; }; -template -using copy_ref_t = typename copy_ref::type; +template <> +struct forward_like_impl { + template + using merge = add_lvalue_reference_t>; + + template + using tuple = add_lvalue_reference_t; -template -struct override_ref { template - using eval = T&; + using language = add_lvalue_reference_t; }; template <> -struct override_ref { +struct forward_like_impl { template - using eval = std::remove_reference_t&&; -}; + using merge = add_rvalue_reference_t>; -template -using override_ref_t = typename override_ref>::template eval; + template + using tuple = add_rvalue_reference_t; -template -struct copy_const; + template + using language = add_lvalue_reference_t; +}; template <> -struct copy_const { +struct forward_like_impl : forward_like_impl { template - using eval = copy_ref_t const>; + using language = add_lvalue_reference_t; }; template <> -struct copy_const { +struct forward_like_impl : forward_like_impl { template - using eval = T; + using language = add_lvalue_reference_t>; }; -template -using copy_const_t = - typename copy_const>>::template eval; - -template -using copy_cvref_t = copy_ref_t>; +template +using model = forward_like_impl>, + rvalue_reference_type ? 2 + : lvalue_reference_type ? 1 + : 0>; } // namespace like_detail /** * @brief Merge the cvref-qualifiers of `T` onto `U` - * - * @tparam T - * @tparam U */ template -using forward_like_t - = like_detail::override_ref_t>>; +using forward_like_t = like_detail::model::template merge; -template -constexpr decltype(auto) forward_like(auto&& arg) noexcept { - return static_cast>(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 +using forward_like_tuple_t = like_detail::model::template tuple; + +template +NEO_ALWAYS_INLINE constexpr forward_like_t forward_like(U&& arg) noexcept { + return static_cast>(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 +#include + #include #define u64 unsigned long long @@ -380,12 +383,74 @@ struct remove_prefix_ { struct from; template + requires((sizeof...(Ts) >= N)) struct from> { - static_assert(sizeof...(Ts) >= N, "remove_prefix N is too large"); using type = decltype(remove_prefix_fn::r(static_cast*>(nullptr)...)); }; }; +template <> +struct remove_prefix_<0> { + template + struct from { + using type = L; + }; +}; + +template <> +struct remove_prefix_<1> { + template + struct from; + + template + struct fn { + template + static L r(void*, tag*...); + }; + + template + requires((sizeof...(Ts) >= 1)) + struct from> { + using type = decltype(fn::r(static_cast*>(nullptr)...)); + }; +}; + +template <> +struct remove_prefix_<2> { + template + struct from; + + template + struct fn { + template + static L r(void*, void*, tag*...); + }; + + template + requires((sizeof...(Ts) >= 1)) + struct from> { + using type = decltype(fn::r(static_cast*>(nullptr)...)); + }; +}; + +template <> +struct remove_prefix_<3> { + template + struct from; + + template + struct fn { + template + static L r(void*, void*, void*, tag*...); + }; + + template + requires((sizeof...(Ts) >= 1)) + struct from> { + using type = decltype(fn::r(static_cast*>(nullptr)...)); + }; +}; + } // namespace detail namespace tacit { @@ -404,11 +469,44 @@ struct remove_prefix { template using remove_prefix = tn detail::remove_prefix_::tl from::type; +namespace detail { + +#if NEO_HAS_BUILTIN(__type_pack_element) +template +struct intrin_at_impl; + +template +struct intrin_at_impl> { + template + using f = __type_pack_element; +}; +#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 +using at = detail::intrin_at_impl::template f; /** - * @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 +using pack_at = __type_pack_element; +#else template using at = head>; +template +using pack_at = at, N>; +#endif namespace tacit { @@ -561,6 +659,51 @@ struct rebind { template using rebind = typename tacit::rebind::tl f; +namespace find_type_detail { + +template +struct find_type_one {}; + +template +struct find_type_one { + enum { value = N }; +}; + +template +struct find_base { + template + struct base {}; +}; + +template <> +struct find_base { + template + struct base { + enum { value = N }; + }; +}; + +template >> +struct finder; + +template +struct finder, std::index_sequence> + : find_base>::template base... {}; + +} // namespace find_type_detail + +template + requires((weak_same_as or ...)) +constexpr std::size_t find_type_v + = find_type_detail::finder, std::index_sequence_for>::value; + +template + requires requires { find_type_detail::finder::value; } +constexpr std::size_t find_type_in = find_type_detail::finder::value; + +template +struct find_type : meta::val> {}; + } // namespace neo::meta #undef u64 diff --git a/src/neo/object_box.hpp b/src/neo/object_box.hpp new file mode 100644 index 0000000..494a7e6 --- /dev/null +++ b/src/neo/object_box.hpp @@ -0,0 +1,346 @@ +#pragma once + +#include "./addressof.hpp" +#include "./attrib.hpp" +#include "./concepts.hpp" +#include "./fwd.hpp" +#include "./like.hpp" +#include "./type_traits.hpp" + +#include +#include +#include + +namespace neo { + +/** + * @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. 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. + * + * 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 +class object_box; + +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 + constexpr friend void swap(object_box& left, + object_box& 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 + requires object_type and (not array_type) +class object_box : 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 U> + requires explicit_convertible_to + // We are explicit if the implicit conversion is not viable + explicit(not implicit_convertible_to) 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 + requires constructible_from + 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("?")); + if (self) { + out.value("{}", out.repr_value(self->get(), "?")); + } + } +}; + +// Implementation of object_box for array types +template +class object_box { + 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 + constexpr object_box(_array_construct, Arr&& arr, std::index_sequence) noexcept + : _array{neo::forward_like(arr[Idx])...} {} + +public: + object_box() = default; + + /** + * @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 ... 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(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 + requires convertible_to + constexpr explicit object_box(FromElement (&&arr)[OtherLen]) noexcept( + noexcept(static_cast(NEO_DECLVAL(FromElement&&)))) + : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence{}) {} + + /** + * @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 + requires convertible_to + constexpr explicit object_box(FromElement const (&arr)[OtherLength]) noexcept( + noexcept(static_cast(NEO_DECLVAL(const FromElement&)))) + : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence{}) {} + + // in-place constructor for moving arrays + template + requires convertible_to + constexpr explicit object_box(std::in_place_t, FromElement (&&arr)[Len]) noexcept( + noexcept(static_cast(NEO_DECLVAL(FromElement&&)))) + : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence{}) {} + + // in-place constructor for copying arrays + template + requires convertible_to + constexpr explicit object_box(std::in_place_t, const FromElement (&arr)[Len]) noexcept( + noexcept(static_cast(NEO_DECLVAL(const FromElement&)))) + : object_box(_array_construct{}, NEO_FWD(arr), std::make_index_sequence{}) {} + + /// Obtain a reference to the boxed 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); } + + /** + * @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("?")); + 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> + { + 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> + { + using Cat = std::common_comparison_category_t< + std::compare_three_way_result_t>>; + return _compare(this->_array, other._array); + } + +private: + template + constexpr bool _equal(const E& left, const E& right) const noexcept { + if constexpr (not neo::array_type) { + 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; + for (; iter != stop; ++iter, ++other_iter) { + if (not _equal(*iter, *other_iter)) { + return false; + } + } + return true; + } + } + + template + constexpr Cat _compare(const E& left, const E& right) const noexcept { + if constexpr (not neo::array_type) { + 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; + Cat r = std::strong_ordering::equal; + for (; l_iter != stop and r == 0; ++l_iter, ++r_iter) { + r = _compare(*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 +class object_box { + using Pointer = add_pointer_t; + Pointer _ptr; + +public: + // boxed references are not default-constructible + constexpr object_box() = delete; + + // Construct a boxed reference from a compatible referred-to type. + template + // 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, Pointer> + explicit constexpr object_box(U&& arg) noexcept + : _ptr(neo::addressof(arg)) {} + + template + requires convertible_to, 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 { + out.type("[boxed {}]", out.template repr_type("?&")); + if (self) { + 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 +class object_box { +public: + object_box() = default; + constexpr explicit object_box(std::in_place_t) noexcept {} + + // Returns void for boxed void + constexpr remove_cv_t get() const noexcept {} + // Returns void for boxed void + constexpr remove_cv_t forward() const noexcept {} + + constexpr void friend do_repr(auto out, const object_box* self) noexcept { + out.type("[boxed {}]", out.template repr_type()); + if (self) { + 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 +object_box(T&& arg) -> object_box; + +} // namespace neo diff --git a/src/neo/object_box.test.cpp b/src/neo/object_box.test.cpp new file mode 100644 index 0000000..c5c16ca --- /dev/null +++ b/src/neo/object_box.test.cpp @@ -0,0 +1,136 @@ +#include "./object_box.hpp" + +#include "./archetypes.hpp" +#include "./repr.hpp" +#include "neo/concepts.hpp" + +#include + +#include + +static_assert(std::constructible_from, int>); +static_assert(std::assignable_from&, neo::object_box>); +static_assert(std::assignable_from&, neo::object_box>); + +struct nontrivial_destructor { + ~nontrivial_destructor() {} +}; +static_assert(neo::trivial_type>); +static_assert(neo::trivially_default_constructible>); +static_assert(neo::trivially_copyable>); +static_assert(neo::trivially_movable>); +static_assert(neo::trivially_copyable>); +static_assert(neo::trivially_copyable>); +static_assert(neo::trivially_copyable>); +static_assert(neo::trivially_copyable>); + +static_assert(std::copyable>); +static_assert(std::semiregular>); +static_assert(std::copyable>); +static_assert(std::copyable>); +static_assert(not std::copyable>); +static_assert(std::movable>>); +static_assert(std::movable&>>); + +static_assert(not neo::copy_constructible>); +static_assert(not neo::copy_assignable>); + +static_assert(not std::default_initializable>); +static_assert(std::default_initializable>); + +TEST_CASE("Construct some boxes") { + neo::object_box b1{7}; + static_assert(std::same_as>); + int value = 9; + neo::object_box b2{value}; + static_assert(std::same_as>); + + CAPTURE(neo::repr(b1)); + CAPTURE(neo::repr(b2)); +} + +TEST_CASE("Void box") { + static_assert(neo::semiregular>); + static_assert(neo::semiregular>); + static_assert(neo::semiregular>); + static_assert(neo::semiregular>); +} + +TEST_CASE("Array box") { + static_assert(neo::object_type); + static_assert(neo::semiregular>); + int carr[3] = {1, 2, 3}; + auto arr = neo::object_box{std::as_const(carr)}; + CHECK(arr.get()[0] == 1); + CHECK(arr.get()[1] == 2); + CHECK(arr.get()[2] == 3); + + neo::object_box box{carr}; + static_assert(std::same_as>); + CHECK(box.get()[0] == 1); + CHECK(box.get()[1] == 2); + CHECK(box.get()[2] == 3); + + neo::object_box box2{NEO_MOVE(carr)}; + static_assert(std::same_as>); + 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>); + CHECK(box3.get()[0] == 1); + CHECK(box3.get()[1] == 2); + CHECK(box3.get()[2] == 3); + + neo::object_box box_copy_const{std::as_const(carr)}; + static_assert(std::same_as>); + CHECK(box_copy_const.get()[0] == 1); + CHECK(box_copy_const.get()[1] == 2); + CHECK(box_copy_const.get()[2] == 3); + + neo::object_box box_copy_rval{NEO_MOVE(carr)}; + static_assert(std::same_as>); + CHECK(box_copy_rval.get()[0] == 1); + CHECK(box_copy_rval.get()[1] == 2); + CHECK(box_copy_rval.get()[2] == 3); + + neo::object_box 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 i{std::in_place, 21}; + CHECK(i.get() == 21); +} + +TEST_CASE("Equality+Ordering") { + SECTION("regular") { + constexpr neo::object_box a{31}; + CHECK(a == a); + CHECK_FALSE(a < a); + } + SECTION("Arrays") { + constexpr neo::object_box a{std::in_place, 1, 3, 4}; + STATIC_REQUIRE(a == a); + STATIC_REQUIRE_FALSE(a < a); + constexpr neo::object_box b{std::in_place, 3, 1, 9}; + STATIC_REQUIRE_FALSE(a == b); + STATIC_REQUIRE(a < b); + } + SECTION("void") { + constexpr neo::object_box a; + CHECK(a == a); + CHECK_FALSE(a < a); + } +} + +static_assert(neo::regular>); +static_assert(neo::regular>); +static_assert(neo::totally_ordered>); +static_assert(neo::totally_ordered>); +static_assert(neo::totally_ordered>); +static_assert(neo::totally_ordered>); +static_assert(neo::regular>); 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 +#include +#include + +namespace neo { + +namespace detail { + +template +struct object_impl; + +template <> +struct object_impl { + template + using f = T; +}; + +template <> +struct object_impl { + template + using f = reference_object; +}; + +template <> +struct object_impl { + template + 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`. + */ +template +using object_t + = detail::object_impl:: + template f; + +} // namespace neo diff --git a/src/neo/opt_ref.hpp b/src/neo/opt_ref.hpp index 3d82575..7e8a177 100644 --- a/src/neo/opt_ref.hpp +++ b/src/neo/opt_ref.hpp @@ -158,6 +158,8 @@ class opt_ref { out.value("nullopt"); } } + + constexpr T* to_address() const noexcept { return _ptr; } }; template diff --git a/src/neo/optional.cpp b/src/neo/optional.cpp new file mode 100644 index 0000000..7d9e065 --- /dev/null +++ b/src/neo/optional.cpp @@ -0,0 +1,12 @@ +#include "./optional.hpp" + +#include "./assert.hpp" + +#include + +using namespace neo; + +void opt_detail::throw_bad_optional() { throw std::bad_optional_access(); } +void opt_detail::terminate_bad_optional() { + neo_assert(expects, false, "Attempted to dereference a disengaged optional object"); +} diff --git a/src/neo/optional.detail.hpp b/src/neo/optional.detail.hpp new file mode 100644 index 0000000..4585641 --- /dev/null +++ b/src/neo/optional.detail.hpp @@ -0,0 +1,129 @@ +#pragma once + +#include +#include + +#include + +namespace neo { + +template +struct optional_traits; + +template +class optional; + +using std::nullopt; +using std::nullopt_t; + +/** + * @brief Detect whether T is a specialization of neo::optional + */ +template +constexpr bool is_optional_v = false; + +template +constexpr bool is_optional_v> = true; + +} // namespace neo + +namespace neo::opt_detail { + +template +concept valid_optional_traits = requires { + typename Traits::state_type; + requires object_type; +} and requires(typename Traits::state_type& mstate, typename Traits::state_type const& cstate) { + { Traits::has_value(cstate) } noexcept -> simple_boolean; + { Traits::get(cstate) } noexcept -> convertible_to>; + { Traits::get(mstate) } noexcept -> convertible_to>; + { Traits::destroy(mstate) } noexcept; + { Traits::trivial_copy } -> simple_boolean; + { Traits::trivial_copy_assign } -> simple_boolean; + { Traits::trivial_move } -> simple_boolean; + { Traits::trivial_move_assign } -> simple_boolean; +}; + +template +struct inherit_from : T {}; + +[[noreturn]] void throw_bad_optional(); +[[noreturn]] void terminate_bad_optional(); + +/** + * This class defines the comparison operators for neo::optional. They are injected + * via ADL from inheritance, to prevent left/right ambiguity during overload selection. + */ +class adl_operators { + template U> + friend constexpr bool operator==(const optional& self, const optional& other) noexcept { + if (self.has_value() != other.has_value()) { + return false; + } + return not self.has_value() or *self == *other; + } + + template + friend constexpr bool operator==(const optional& self, nullopt_t) noexcept { + return not self.has_value(); + } + + template + requires(not is_optional_v) and equality_comparable_with + friend constexpr bool operator==(const optional& self, const U& other) noexcept { + return self.has_value() and *self == other; + } + + /** + * @brief Compare an optional against another optional of a value_type + * that is comparable to the value_type of this optional. + * + * A null optional is always less than an engaged one, two null optionals + * are equivalent, and two engaged optionals are compared by the value + * that they contain. + */ + template U> + friend constexpr std::compare_three_way_result_t + operator<=>(const optional& self, const optional other) noexcept { + if (self.has_value() and other.has_value()) { + return std::compare_three_way{}(*self, *other); + } else { + return self.has_value() <=> other.has_value(); + } + } + + /** + * @brief Compare the optional with a null-constant. + * + * The null constant is always less-than any engaged optional, and equivalent + * to a null optional. + */ + template + friend constexpr std::strong_ordering // + operator<=>(const optional& self, nullopt_t) noexcept { + if (self.has_value()) { + return std::strong_ordering::greater; + } else { + return std::strong_ordering::equal; + } + } + + /** + * @brief Compare the optional with a value of another type which is comparable with the + * optional's value_type + * + * A null optional is always less-than any other value + */ + template + requires(not is_optional_v) and three_way_comparable_with + friend constexpr std::compare_three_way_result_t // + operator<=>(const optional& self, const U& value) noexcept { + if (self.has_value()) { + return std::compare_three_way{}(*self, value); + } else { + return std::strong_ordering::less; + } + } +}; + +} // namespace neo::opt_detail \ No newline at end of file diff --git a/src/neo/optional.hpp b/src/neo/optional.hpp index 110e491..92c7a3d 100644 --- a/src/neo/optional.hpp +++ b/src/neo/optional.hpp @@ -1,37 +1,544 @@ #pragma once +#include "./optional.detail.hpp" + +#include "./addressof.hpp" #include "./attrib.hpp" -#include "./concepts.hpp" +#include "./constexpr_union.hpp" #include "./declval.hpp" +#include "./emplacement.hpp" +#include "./invoke.hpp" +#include "./object_t.hpp" +#include "./returns.hpp" +#include "./storage.hpp" +#include "./swap.hpp" +#include "./type_traits.hpp" +#include +#include #include namespace neo { -namespace opt_detail { +/** + * @brief Provides a stronger, leaner, and faster-compiling version of std::optional + * + * This optional supports any type that provides an instance of optional_traits, + * which by default includes any type that supports object_box (including `void` and reference + * types). + * + * @tparam T The type held by the optional + */ +template +class optional : public opt_detail::adl_operators { + // optional_traits for the optional + using traits = optional_traits; + + static_assert(opt_detail::valid_optional_traits); + + // The stored state type, obtained from the traits + using state_type = traits::state_type; + + // The state that is held be the optional. Passed to/from the traits for operations + NEO_NO_UNIQUE_ADDRESS state_type _state = state_type(); + + /// If we do not currently hold any value, throws bad_optional_access + 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. + constexpr void _assert_has_value() const noexcept { + if (not has_value()) { + opt_detail::terminate_bad_optional(); + } + } + + /// Perform a copy-construct/copy-assignment, which may include moving, depending + /// on the cvref of "other_storage" and the behavior of our optional_traits + 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)) { + // Ther other has a value. Do a copy (may move): + traits::copy(_state, NEO_FWD(other_storage)); + } else { + // Both are empty. Nothing to do + } + } else { + // We have a value. We may assigned over our own + if (traits::has_value(other_storage)) { + // Assign our value over the other's value + traits::assign(_state, NEO_FWD(other_storage)); + } else { + // Other is empty, so we'll become empty too + traits::destroy(_state); + } + } + } + + template > + static constexpr Ret do_and_then(Self&& self, Fn&& fn) { + static_assert(is_optional_v, + "and_then() requires that the operation returns an optional. Did you mean to " + "use opt.transform()?"); + if (self.has_value()) { + return NEO_INVOKE(NEO_FWD(fn), *NEO_FWD(self)); + } else { + return {}; + } + } + + template > + static constexpr optional do_transform(Self&& self, Fn&& fn) { + if (self.has_value()) { + return optional(NEO_INVOKE(NEO_FWD(fn), *NEO_FWD(self))); + } else { + return optional{}; + } + } + +public: + /// The lvalue-reference type that we return + using reference = add_lvalue_reference_t; + /// The lvalue-reference-to-const type that we return + using const_reference = add_const_reference_t; + /// The rvalue-reference type that we return from dereferencing an rvalue optional + using rvalue_reference = add_rvalue_reference_t; + /// The rvalue-reference type that we return from dereferencing a const rvalue optional + using const_rvalue_reference = add_rvalue_reference_t>; + /// The pointer type that we return from operator->() + using pointer = add_pointer_t; + /// The pointer type that we return from operator->() const + using const_pointer = add_const_pointer_t; + + /// Default-constructs as a disengaged optional + constexpr optional() noexcept = default; + /// Simply constructs as a null optional + constexpr optional(nullopt_t) noexcept {} + + /// Copy-construct an optional from an optional of the same type + constexpr optional(const optional&) noexcept + requires traits::trivial_copy + = default; + constexpr optional(const optional& o) noexcept(nothrow_constructible_from) + requires copy_constructible and (not traits::trivial_copy) + { + _assign(o._state); + } + + /// Move-construct an optional from an optional of the same type + constexpr optional(optional&&) noexcept + requires traits::trivial_move + = default; + constexpr optional(optional&& o) noexcept(nothrow_constructible_from) + requires move_constructible and (not traits::trivial_move) + { + _assign(NEO_MOVE(o)._state); + } + + /** + * @brief Copy-construct from an optional of a differing type + */ + template ::value_type> + requires is_optional_v> + explicit(not convertible_to) constexpr optional(OtherOpt&& other) // + noexcept(nothrow_constructible_from) + requires constructible_from + and (alike + or not(constructible_from> + and constructible_from> + and constructible_from>> + and constructible_from> // + and convertible_to, T> // + and convertible_to, T> // + and convertible_to>, T> // + and convertible_to, T> // + )) + { + if (not other.has_value()) { + // Okay: Do nothing (we are empty) + } else { + traits::construct(_state, *NEO_FWD(other)); + } + } + + template + constexpr explicit optional(std::in_place_t, + Args&&... args) // + noexcept(nothrow_constructible_from) + requires constructible_from + { + traits::construct(_state, NEO_FWD(args)...); + } + + constexpr explicit optional(std::in_place_t) noexcept + requires void_type + { + traits::construct(_state); + } + + template + constexpr explicit(not convertible_to) + optional(U&& arg) noexcept(nothrow_constructible_from) + requires constructible_from // + and unalike // + and (not is_optional_v>) + { + traits::construct(_state, NEO_FWD(arg)); + } + + constexpr optional& operator=(const optional&) noexcept + requires traits::trivial_copy_assign + = default; + constexpr optional& + operator=(const optional& o) noexcept(noexcept(traits::copy(_state, o._state)) // + and noexcept(traits::assign(_state, o._state))) + requires copy_assignable and (not traits::trivial_copy_assign) + { + _assign(NEO_MOVE(o)._state); + return *this; + } + + constexpr optional& operator=(optional&&) noexcept + requires traits::trivial_move_assign + = default; + constexpr optional& + operator=(optional&& o) noexcept(noexcept(traits::copy(_state, NEO_MOVE(o)._state)) // + and noexcept(traits::assign(_state, NEO_MOVE(o)._state))) + requires move_assignable and (not traits::trivial_move_assign) + { + _assign(NEO_MOVE(o)._state); + return *this; + } + + constexpr reference operator*() & noexcept { + _assert_has_value(); + return traits::get(_state); + } + constexpr const_reference operator*() const& noexcept { + _assert_has_value(); + return traits::get(_state); + } + + constexpr rvalue_reference operator*() && noexcept { + _assert_has_value(); + return (rvalue_reference)traits::get(_state); + } + constexpr const_rvalue_reference operator*() const&& noexcept { + _assert_has_value(); + return (const_rvalue_reference)traits::get(_state); + } + + constexpr const_pointer operator->() const noexcept { return NEO_ADDRESSOF(**this); } + 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 auto value() & -> reference { + _check_has_value(); + return **this; + } + + constexpr auto value() && -> rvalue_reference { + _check_has_value(); + return *NEO_MOVE(*this); + } + + constexpr auto value() const& -> const_reference { + _check_has_value(); + return **this; + } + + constexpr auto value() const&& -> const_rvalue_reference { + _check_has_value(); + return *NEO_MOVE(*this); + } + + template + constexpr auto value_or(U&& dflt) & -> common_reference_t { + if (has_value()) { + return **this; + } else { + return NEO_FWD(dflt); + } + } + + template + constexpr auto value_or(U&& dflt) const& -> common_reference_t { + if (has_value()) { + return **this; + } else { + return NEO_FWD(dflt); + } + } + + template + constexpr auto value_or(U&& dflt) && -> common_reference_t { + if (has_value()) { + return *NEO_MOVE(*this); + } else { + return NEO_FWD(dflt); + } + } + + template + constexpr auto value_or(U&& dflt) const&& -> common_reference_t { + if (has_value()) { + return *NEO_MOVE(*this); + } else { + return NEO_FWD(dflt); + } + } + + /** + * @brief If this optional currently holds a value, returns a pointer to that + * value. Otherwise, returns nullptr + */ + constexpr pointer as_pointer() noexcept { + return has_value() ? NEO_ADDRESSOF(**this) : nullptr; + } + constexpr const_pointer as_pointer() const noexcept { + return has_value() ? NEO_ADDRESSOF(**this) : nullptr; + } + + /** + * @brief Swap the value contained between two optionals. + * + * Requires that the values be swappable + * + * @param other The optional that will be swapped. + */ + constexpr void swap(optional& other) // + noexcept(noexcept(traits::copy(_state, NEO_MOVE(other._state))) // + and noexcept(traits::swap(_state, _state))) + requires requires { + traits::copy(_state, NEO_MOVE(_state)); + traits::swap(_state, other._state); + } + { + if (not has_value()) { + if (other.has_value()) { + traits::copy(_state, NEO_MOVE(other._state)); + } else { + // No one has a value. Nothing to do + } + } else { + if (other.has_value()) { + traits::swap(_state, other._state); + } else { + other.swap(*this); + } + } + } + + /** + * @brief Clear the value held by this optional, if non-empty. + */ + constexpr void reset() noexcept { + if (has_value()) { + traits::destroy(_state); + } + } + + /** + * @brief In-place contsruct a new value within the optional. + * + * If the optional held a value, the existing value is destroyed. + * + * @param args The arguments to the constructor of the underlying T + * @return A reference to the underlying constructed value. + */ + template + constexpr reference + emplace(Ts&&... args) noexcept(noexcept(traits::construct(_state, NEO_FWD(args)...))) + requires requires { traits::construct(_state, NEO_FWD(args)...); } + { + reset(); + traits::construct(_state, NEO_FWD(args)...); + return traits::get(_state); + } + + template + constexpr auto and_then(F&& fun) & // + NEO_RETURNS(this->do_and_then(*this, NEO_FWD(fun))); + + template + constexpr auto and_then(F&& fun) const& // + NEO_RETURNS(this->do_and_then(*this, NEO_FWD(fun))); + + template + constexpr auto and_then(F&& fun) && // + NEO_RETURNS(this->do_and_then(NEO_MOVE(*this), NEO_FWD(fun))); + + template + constexpr auto and_then(F&& fun) const&& // + NEO_RETURNS(this->do_and_then(NEO_MOVE(*this), NEO_FWD(fun))); + + template + constexpr auto transform(F&& fn) & // + NEO_RETURNS(this->do_transform(*this, NEO_FWD(fn))); + template + constexpr auto transform(F&& fn) const& // + NEO_RETURNS(this->do_transform(*this, NEO_FWD(fn))); + template + constexpr auto transform(F&& fn) && // + NEO_RETURNS(this->do_transform(NEO_MOVE(*this), NEO_FWD(fn))); + template + constexpr auto transform(F&& fn) const&& // + NEO_RETURNS(this->do_transform(NEO_MOVE(*this), NEO_FWD(fn))); + + template + constexpr optional or_else(F&& fn) const& + requires copy_constructible + { + if (has_value()) { + return *this; + } else { + return NEO_INVOKE(NEO_FWD(fn)); + } + } -template -struct inherit_from : T {}; + template + constexpr optional or_else(F&& fn) && + requires movable + { + if (has_value()) { + return *NEO_FWD(*this); + } else { + return NEO_INVOKE(NEO_FWD(fn)); + } + } +}; -// Hack: A concept that matches a type T that is a in_place_t tag template -concept in_place_t_tag = requires { - // Check for an injected-name matching in_place_t - typename inherit_from::in_place_t; -} -// And that the nested name is the same as the enclosing class -&&weak_same_as::in_place_t>; - -// A tiny in-place tag we can use -struct opt_in_place_t { - using in_place_t = opt_in_place_t; +explicit optional(const T&) -> optional; + +/** + * @brief The default state type for optional values + * + * @tparam T The stored type + */ +template +struct default_optional_state { +public: + NEO_NO_UNIQUE_ADDRESS constexpr_union> onion; + bool has_value = false; + + default_optional_state() = default; }; -// (This is all so we don't pull ) -} // namespace opt_detail +/** + * @brief Specialize to customize the implementation of neo::optional + * + * @tparam T The type for which we are specializing + * + * A valid specialization of optional_traits defines the following: + * + * - `typename state_type` must be a type that is default-constructible. A default-constructed + * state_type object MUST represent an unalive "disengaged" state. The optional + * will inherit its copy/move/assign/destruct attributes from the state_type object, + * i.e. whether it is trivial, copyable, constexpr, noexcept, etc. + * - static has_value(const state_type&) noexcept -> bool + * - Must return `true` if the state is alive, otherwise `false` + * - static get(state_type [const] &) -> T [const] & + * - Obtain a reference to the managed value. Should propagate cv + * qualifiers correctly for the underlying type. May assume that the + * state is alive. + * - static destroy(state_type&) -> void + * - Should clear the live value in the state and reset to null. May assume + * that the state is alive. + * - static construct(state_type&, ...) + * - Should construct a new live value from the given arguments. May assume + * that the state is dead. + * - static copy(state_type& into, state_type [const] [ref] from) + * - Should copy/move construct from live state `from` into disengaged + * state `into` + * - static assign(state_type& into, state_type [const] [ref] from) + * - Should copy/move assign from live state `from` into live state `into` + * + * - static constexpr bool trivial_move • Allow trivial moves of the state + * - static constexpr bool trivial_move_assign • Allow trivial move-assignment of the state + * - static constexpr bool trivial_copy • Allow trivial copy of the state + * - static constexpr bool trivial_copy_assign • Allow trivial copy-assignment of the state + */ +template +struct optional_traits { + using state_type = default_optional_state; + + static constexpr bool trivial_copy = copy_constructible; + static constexpr bool trivial_move = move_constructible; + static constexpr bool trivial_copy_assign = trivially_copyable; + static constexpr bool trivial_move_assign = trivially_movable; + + constexpr static bool has_value(const state_type& st) noexcept { return st.has_value; } + constexpr static add_lvalue_reference_t get(state_type& st) noexcept { + return static_cast>(st.onion._0); + } + constexpr static add_const_reference_t get(const state_type& st) noexcept { + return static_cast>(st.onion._0); + } + constexpr static void destroy(state_type& st) noexcept { + st.onion.template destroy<0>(); + st.has_value = false; + } + template + constexpr static void + construct(state_type& st, Args&&... args) noexcept(nothrow_constructible_from) { + st.onion.template construct<0>(NEO_FWD(args)...); + st.has_value = true; + } + + template + constexpr static void copy(state_type& into, O&& from) // + noexcept(nothrow_constructible_from) // + { + construct(into, NEO_FWD(from).onion._0); + } + + template + constexpr static void assign(state_type& into, O&& from) // + noexcept(std::is_nothrow_assignable_v) // + { + into.onion._0 = NEO_FWD(from).onion._0; + } + + constexpr static void swap(state_type& a, state_type& b) { neo::swap(a.onion._0, b.onion._0); } +}; /** - * @brief Provides storage for an object of type 'T'. + * @brief Specialization for reference types + */ +template +struct optional_traits { + using state_type = remove_reference_t*; + + static constexpr bool trivial_copy = true; + static constexpr bool trivial_move = true; + static constexpr bool trivial_copy_assign = true; + static constexpr bool trivial_move_assign = true; + + constexpr static bool has_value(state_type s) noexcept { return s != nullptr; } + constexpr static Ref& get(state_type s) noexcept { return *s; } + + constexpr static void destroy(state_type& s) noexcept { s = nullptr; } + constexpr static void construct(state_type& into, Ref from) noexcept { + into = NEO_ADDRESSOF(from); + } + + // copy/assign/swap are not needed, since we are trivially copy/move-able +}; + +/** + * @brief Provides constexpr-ready storage for an object of type 'T'. * * The storage begins uninitialized. The lifetime of the `.value` members must * be managed manually. @@ -39,18 +546,21 @@ struct opt_in_place_t { * @tparam T The type that is stored in the union. */ template -union nano_opt_storage { - char _empty; - T value; +union [[deprecated("Prefer neo::storage_for")]] nano_opt_storage { + /// A valueless union member. The initial value + NEO_NO_UNIQUE_ADDRESS unit _empty{}; + // The storage that is managed by this union. + using boxed_t = object_box; + NEO_NO_UNIQUE_ADDRESS boxed_t box; /** * @brief Construct a value in-place. */ template - constexpr explicit nano_opt_storage(opt_detail::in_place_t_tag auto, Args&&... args) // - noexcept(nothrow_constructible_from) // - requires constructible_from // - : value((Args &&)(args)...) {} + constexpr explicit nano_opt_storage(std::in_place_t, Args&&... args) // + noexcept(nothrow_constructible_from) // + requires constructible_from // + : box((Args&&)(args)...) {} /// Default-construct as disenganged constexpr nano_opt_storage() = default; @@ -58,7 +568,7 @@ union nano_opt_storage { requires(not trivially_default_constructible) {} -#if !NEO_COMPILER_IS_CLANG +#if !NEO_COMPILER(Clang) #define NEO_NANO_OPT_SUPPORTS_TRIVIAL_DESTRUCTIBILITY 1 NEO_CONSTEXPR_DESTRUCTOR ~nano_opt_storage() = default; NEO_CONSTEXPR_DESTRUCTOR ~nano_opt_storage() @@ -68,22 +578,24 @@ union nano_opt_storage { #define NEO_NANO_OPT_SUPPORTS_TRIVIAL_DESTRUCTIBILITY 0 NEO_CONSTEXPR_DESTRUCTOR ~nano_opt_storage() {} #endif + + void destroy() noexcept { neo::destroy_at(&box); } }; /** * @brief An extremely minimal optional-lite class. * - * @tparam T + * @tparam T The type stored by this optional */ template class nano_opt { - using storage_type = nano_opt_storage; + using storage_type = storage_for; storage_type _storage; bool _active = false; void _destroy_nocheck() noexcept { - _storage.value.~T(); + _storage.destroy(); _active = false; } @@ -94,17 +606,18 @@ class nano_opt { // Construct as a new T template requires weak_same_as, T> // - constexpr nano_opt(Arg&& arg) - : _storage(opt_detail::opt_in_place_t{}, (Arg &&)(arg)) - , _active(true) {} + constexpr nano_opt(Arg&& arg) noexcept(nothrow_constructible_from) { + this->emplace(NEO_FWD(arg)); + } // Construct as a new T with the given arguments - template - constexpr explicit nano_opt(InPlace tag, Args&&... args) // - noexcept(nothrow_constructible_from) // - requires constructible_from // - : _storage(tag, (Args &&)(args)...) - , _active(true) {} + template + constexpr explicit nano_opt(std::in_place_t, Args&&... args) // + noexcept(nothrow_constructible_from) // + requires constructible_from // + { + this->emplace(NEO_FWD(args)...); + } // Pick the type of destructor we want based on whether the underlying type is triviallty // destructible @@ -136,7 +649,7 @@ class nano_opt { requires(not trivially_constructible) { if (other.has_value()) { - emplace((T &&)(other)); + emplace(NEO_MOVE(other).get()); } } @@ -172,13 +685,13 @@ class nano_opt { { if (has_value()) { if (other.has_value()) { - get() = (T &&)(other.get()); + get() = (T&&)(other.get()); } else { _destroy_nocheck(); } } else { if (other.has_value()) { - emplace((T &&)(other.get())); + emplace((T&&)(other.get())); } else { // Nothing to do } @@ -202,7 +715,7 @@ class nano_opt { requires constructible_from { reset(); - ::new (const_cast(static_cast(&_storage.value))) T((Args &&)(args)...); + _storage.construct(NEO_FWD(args)...); _active = true; return get(); } @@ -211,10 +724,10 @@ class nano_opt { constexpr bool has_value() const noexcept { return _active; } /// Obtain the underlying value. - constexpr T& get() & noexcept { return _storage.value; } - constexpr const T& get() const& noexcept { return _storage.value; } - constexpr T&& get() && noexcept { return (T &&) _storage.value; } - constexpr const T&& get() const&& noexcept { return (T &&) _storage.value; } + constexpr T& get() & noexcept { return _storage.get(); } + constexpr const T& get() const& noexcept { return _storage.get(); } + constexpr T&& get() && noexcept { return NEO_MOVE(_storage).get(); } + constexpr const T&& get() const&& noexcept { return NEO_MOVE(_storage).get(); } friend constexpr void do_repr(auto out, const nano_opt* self) noexcept requires requires { out.repr(NEO_DECLVAL(const T&)); } @@ -234,3 +747,26 @@ class nano_opt { }; } // namespace neo + +template + requires neo::object_type and requires { std::hash{}(NEO_DECLVAL(const T&)); } +struct std::hash> { + constexpr std::size_t operator()(const neo::optional& opt) noexcept { + if (opt) { + return std::hash()(*opt); + } else { + return std::hash()(nullptr) ^ std::hash{}(1729); + } + } +}; + +template +struct std::hash> { + constexpr std::size_t operator()(const neo::optional& opt) noexcept { + if (opt) { + return std::hash()(NEO_ADDRESSOF(*opt)) ^ std::hash{}(89); + } else { + return std::hash()(nullptr) ^ std::hash{}(42); + } + } +}; diff --git a/src/neo/optional.test.cpp b/src/neo/optional.test.cpp index bdbb7e6..17ba374 100644 --- a/src/neo/optional.test.cpp +++ b/src/neo/optional.test.cpp @@ -1,9 +1,19 @@ #include "./optional.hpp" +#include "./archetypes.hpp" +#include "./platform.hpp" #include "./repr.hpp" #include "./test_concept.hpp" +#include "neo/concepts.hpp" +#include "neo/type_traits.hpp" #include +#include +#include + +NEO_GNU_LIKE_PRAGMA(GCC diagnostic ignored "-Wdeprecated-declarations"); + +namespace arch = neo::arch; struct trivial { int i; @@ -11,7 +21,6 @@ struct trivial { struct trivial_default_constructible { int i; - ~trivial_default_constructible() {} }; struct trivial_destructible { @@ -23,23 +32,90 @@ struct nontrivial { ~nontrivial() {} }; +struct not_default_constructible { + int a; + constexpr explicit not_default_constructible(int a_) + : a(a_) {} +}; + +// Optional traits: + +static_assert(not neo::empty_type>); +static_assert(not neo::trivial_type>); +static_assert(neo::trivially_assignable&, + neo::optional&>); +static_assert(neo::trivially_assignable&, + neo::optional const&>); +static_assert(neo::trivially_assignable&, + neo::optional&&>); +static_assert(neo::trivially_assignable&, + neo::optional&>); +static_assert(neo::trivially_assignable&, + neo::optional const&>); +static_assert(neo::trivially_assignable&, + neo::optional&&>); +static_assert(neo::trivially_copyable>); + +static_assert(neo::trivially_copyable>); +static_assert(neo::copyable>); +static_assert(neo::copyable>); +static_assert(not neo::copyable>); +static_assert(not neo::copyable>); +static_assert(neo::movable>); +static_assert(neo::movable>); + +static_assert(neo::trivially_copyable>); +static_assert(neo::copyable>); +static_assert(neo::copyable>); +static_assert(neo::copyable>); +static_assert(neo::copyable>); + +static_assert(neo::trivially_movable>); +static_assert(neo::trivially_movable>); + +static_assert(neo::trivially_movable>); +static_assert(neo::trivially_movable>); +static_assert(neo::movable>); +static_assert(neo::movable>); + +static_assert(not neo::trivial_type>); +static_assert(neo::trivially_assignable&, + neo::optional&>); +static_assert(neo::trivially_assignable&, + neo::optional const&>); +static_assert(neo::trivially_assignable&, + neo::optional&&>); +static_assert(neo::trivially_assignable&, + neo::optional&>); +static_assert(neo::trivially_assignable&, + neo::optional const&>); +static_assert(neo::trivially_assignable&, + neo::optional&&>); +static_assert(neo::trivially_copyable>); + +// static_assert(not neo::copy_constructible>); + +// The no_unique_address makes this just a single boolean: +// XXX: Disabled: MSVC doesn't seem to emit a single boolean? +// static_assert(sizeof(neo::optional) == 1); +static_assert(sizeof(neo::optional) == sizeof(neo::unit*)); + #if NEO_NANO_OPT_SUPPORTS_TRIVIAL_DESTRUCTIBILITY NEO_TEST_CONCEPT(std::is_trivially_destructible_v>); -NEO_TEST_CONCEPT(std::is_trivially_default_constructible_v>); +NEO_TEST_CONCEPT(std::is_trivially_copy_constructible_v>); #endif /// XXX: Bug in language/compilers sees a non-trivial destructor as invalidating /// trivial_default_constructible. As such, these checks will fail: // NEO_TEST_CONCEPT(std::is_trivially_default_constructible_v); -// NEO_TEST_CONCEPT(std::is_trivially_default_constructible_v< +// NEO_TEST_CONCEPT(std::is_trivially_copy_constructible_v< // neo::nano_opt_storage>); /// Refer: https://cplusplus.github.io/LWG/issue2116 and /// https://gcc.gnu.org/bugzilla/show_bug.cgi?id=51452 -NEO_TEST_CONCEPT( - !std::is_trivially_destructible_v>); +NEO_GNU_LIKE_PRAGMA(GCC diagnostic ignored "-Wdeprecated"); -NEO_TEST_CONCEPT(!std::is_trivially_default_constructible_v>); +NEO_TEST_CONCEPT(!std::is_trivially_copy_constructible_v>); NEO_TEST_CONCEPT(!std::is_trivially_destructible_v>); // Check that nano_opt is constexpr-able @@ -69,3 +145,216 @@ TEST_CASE("Constexpr nano_opt") { CHECK(!null.has_value()); CHECK(neo::repr(null).string() == "[neo::nano_opt nullopt]"); } + +TEST_CASE("neo::optional") { + // Constexpr ok? + constexpr auto opt_null [[maybe_unused]] = neo::optional{}; + using opt_int = neo::optional; + + // Copy construct ok + opt_int i1 [[maybe_unused]] = 12; +} + +template +void full_use(neo::optional o) { + o = neo::optional(o); + o = NEO_MOVE(o); + o.has_value(); + o.emplace(); + CHECKED_IF(o.has_value()) { + *o; + CHECK_NOTHROW(o.value()); + } + o.reset(); + o.reset(); + CHECK_FALSE(o.has_value()); + o.emplace(); + o.emplace(); + CHECK(o.has_value()); + o = {}; + CHECK_FALSE(o.has_value()); + o = neo::optional(); + CHECK_FALSE(o); + auto p = o; + o.swap(p); + auto dup = o; + auto dup2 = NEO_MOVE(dup); + dup = dup2; + dup2 = NEO_MOVE(dup); +} + +TEST_CASE("Optional of int") { + constexpr auto x = neo::optional(); + full_use(x); + x <=> x; +} + +TEST_CASE("Optional of void") { + constexpr auto x = neo::optional(); + full_use(x); +} + +TEST_CASE("Optional of nontrivial") { + auto x = neo::optional("Howdy neighbor"); + full_use(x); + CHECK((x <=> x) == std::strong_ordering::equal); + CHECK(std::hash>()(x) != 0); +} + +TEST_CASE("Optional and_then") { + auto x = neo::optional(12); + CHECK(*x.and_then([](auto x) { return neo::optional(x + 2); }) == 14); + CHECK(*x.transform([](auto x) { return x + 2; }) == 14); +} + +TEST_CASE("Optional of reference") { + std::string s = "Hello, reference"; + auto opt_string = neo::optional(s); + // full_use(x); + CHECK((opt_string <=> opt_string) == std::strong_ordering::equal); + CHECK(opt_string == s); + CHECK(opt_string == "Hello, reference"); + CHECK(opt_string != std::nullopt); + CHECK(opt_string > std::nullopt); + CHECK(std::hash>()(opt_string) != 0); + // Compare two optionals of different types: + auto opt_sv = neo::optional(std::string_view("Hello, reference")); + CHECK(opt_sv == opt_string); + + std::string other = "Other string"; + // Rebind: + opt_string = other; + CHECK(opt_sv != opt_string); + CHECK(*opt_string == "Other string"); +} + +struct never_defined; + +TEST_CASE("Optional of incomplete reference") { + neo::optional oref; + CHECK_FALSE(oref.has_value()); +} + +// XXX: MSVC has trouble with our designated-init trickery below? +#if !NEO_COMPILER(MSVC) + +#define DECL_CHECKER(Concept, ...) \ + template \ + struct check_##Concept { \ + template \ + requires(__VA_ARGS__) \ + using f = int; \ + }; \ + template <> \ + struct check_##Concept { \ + template \ + requires(not(__VA_ARGS__)) \ + using f = int; \ + }; \ + template \ + using check_##Concept##_t = check_##Concept::template f + +DECL_CHECKER(copy_constructible, neo::copy_constructible); +DECL_CHECKER(move_constructible, neo::move_constructible); +DECL_CHECKER(copy_assignable, neo::copy_assignable); +DECL_CHECKER(move_assignable, neo::move_assignable); + +DECL_CHECKER(trivially_copy_constructible, neo::trivially_constructible); +DECL_CHECKER(trivially_move_constructible, neo::trivially_constructible); +DECL_CHECKER(trivially_copy_assignable, neo::trivially_assignable); +DECL_CHECKER(trivially_move_assignable, neo::trivially_assignable); + +struct Attrs { + struct ctasn { + bool construct = true, assign = construct; + }; + struct triv { + ctasn copy, move; + bool destroy = true; + }; + static constexpr ctasn ctandasn = ctasn{.construct = true, .assign = true}; + + ctasn copy = {}, move = copy; + triv trivial = triv{ + .copy = copy, + .move = move, + }; +}; +template +struct exec_checks { + using opt = neo::optional; + static constexpr int + foo(check_copy_constructible_t = 0, + check_copy_assignable_t = 0, + check_move_constructible_t = 0, + check_move_assignable_t = 0, + check_trivially_copy_constructible_t = 0, + check_trivially_move_constructible_t = 0, + check_trivially_copy_assignable_t = 0, + check_trivially_move_assignable_t = 0) { + return 42; + } + static_assert(foo() == 42); +}; + +template +constexpr auto exec_checks_v = exec_checks{}; + +template +struct unused { + constexpr unused(auto...) {} +}; + +template +unused(Xs...) -> unused<0>; + +constexpr auto u [[maybe_unused]] = unused{ + exec_checks_v, + exec_checks_v, + exec_checks_v, + exec_checks_v, + Attrs{ + .copy = {false}, + .move = {true}, + .trivial = {.copy = {false}, .move = {.construct = true, .assign = false}}, + }>, + exec_checks_v, + Attrs{ + .copy = {false}, + .move = {true}, + .trivial = {.copy = {false}, .move = {false}}, + }>, + exec_checks_v, + Attrs{.copy = {false}, .move = {true}}>, + exec_checks_v, + Attrs{}>, + exec_checks_v, + Attrs{}>, + exec_checks_v, + Attrs{.trivial = {.copy = {false}, .move = {false}, .destroy = false}}>, + exec_checks_v, + Attrs{}>, +}; + +#endif diff --git a/src/neo/out.hpp b/src/neo/out.hpp index b2c4f91..f0fc776 100644 --- a/src/neo/out.hpp +++ b/src/neo/out.hpp @@ -2,7 +2,7 @@ #include "./declval.hpp" #include -#include +#include #include @@ -30,9 +30,8 @@ struct output { constexpr operator T&() const noexcept { return _dest; } - friend constexpr void do_repr(auto out, const output* self) noexcept requires requires { - out.repr(NEO_DECLVAL(const T&)); - } + friend constexpr void do_repr(auto out, const output* self) noexcept + requires requires { out.repr(NEO_DECLVAL(const T&)); } { out.type("neo::output"); if (self) { @@ -52,7 +51,7 @@ struct output { */ template class optional_output { - opt_ref _dest; + optional _dest; public: constexpr optional_output() = default; @@ -72,17 +71,15 @@ class optional_output { } } - constexpr opt_ref get() const noexcept { return _dest; } + constexpr optional get() const noexcept { return _dest; } constexpr T& operator*() const noexcept { return *_dest; } constexpr T* operator->() const noexcept { return _dest.operator->(); } constexpr explicit operator bool() const noexcept { return bool(_dest); } - friend constexpr void do_repr(auto out, - const optional_output* self) noexcept requires requires { - out.repr(NEO_DECLVAL(const T&)); - } + friend constexpr void do_repr(auto out, const optional_output* self) noexcept + requires requires { out.repr(NEO_DECLVAL(const T&)); } { out.type("neo::optional_output<{}>", out.template repr_type()); if (self and *self) { diff --git a/src/neo/overload.hpp b/src/neo/overload.hpp index 8ca349e..0c8d069 100644 --- a/src/neo/overload.hpp +++ b/src/neo/overload.hpp @@ -3,8 +3,8 @@ #include "./attrib.hpp" #include "./fwd.hpp" #include "./invoke.hpp" +#include "./object_box.hpp" #include "./returns.hpp" -#include "./scalar_box.hpp" #include "./tag.hpp" #include @@ -16,7 +16,7 @@ namespace detail { template class overload_fn { - NEO_NO_UNIQUE_ADDRESS neo::scalar_box _func; + NEO_NO_UNIQUE_ADDRESS neo::object_box _func; public: constexpr overload_fn() = default; @@ -36,7 +36,7 @@ class overload_fn { template requires(not neo_is_member_pointer(remove_cvref_t)) class overload_fn { - NEO_NO_UNIQUE_ADDRESS neo::scalar_box _func; + NEO_NO_UNIQUE_ADDRESS neo::object_box _func; public: constexpr overload_fn() = default; @@ -88,7 +88,7 @@ template struct ordered_overload_impl : ordered_overload_impl { using base_type = ordered_overload_impl; - NEO_NO_UNIQUE_ADDRESS neo::scalar_box _my_fn; + NEO_NO_UNIQUE_ADDRESS neo::object_box _my_fn; // Default constructor constexpr ordered_overload_impl() = default; 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 +#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` struct to pass a variadic list of types - */ -template -struct pick_type; +template +using pick_type_of_t [[deprecated("Use neo::meta::at")]] = meta::at; -template <> -struct pick_type<0> { - template - struct from { - using type = T; - }; -}; - -template <> -struct pick_type<1> { - template - struct from { - using type = T; - }; -}; - -template <> -struct pick_type<2> { - template - struct from { - using type = T; - }; -}; - -template <> -struct pick_type<3> { - template - struct from { - using type = T; - }; -}; - -template -requires(N >= 4 and N < 16) struct pick_type { - template - struct from : pick_type::template from {}; -}; - -template -requires(N >= 16 and N < 64) struct pick_type { - template - struct from : pick_type::template from {}; -}; - -template -requires(N >= 64) struct pick_type { - template - struct from : pick_type::template from {}; -}; - -/** - * @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 -using pick_type_t = typename pick_type::template from::type; - -/** - * @brief Pick the Nth type argument from a template specialization - * - * @tparam N The index to pick from - */ -template -struct pick_type_of { - /// Specify the template specialization to pick from - template - struct from; - - template