[clang] [PATCH] [clang][frontend] Fix AllocKind retrieving for `CXXConstructorDecl` refs #132794 (PR #133077)
Paul Schwabauer via cfe-commits
cfe-commits at lists.llvm.org
Wed Mar 26 07:17:02 PDT 2025
https://github.com/koplas updated https://github.com/llvm/llvm-project/pull/133077
>From 5139570c2948231aa141a3c7a53651e83ddc5bec Mon Sep 17 00:00:00 2001
From: koplas <paul at schwabauer.co>
Date: Wed, 26 Mar 2025 13:49:44 +0100
Subject: [PATCH] [PATCH] [clang][frontend] Fix AllocKind retrieving for
`CXXConstructorDecl` refs #132794
When getting the `ExplicitSpecifier` of the `CXXConstructorDecl`, one
of the canonical declaration is returned. When writing the declaration
record with `ExplicitSpecifier`, the `AllocKind` of the canonical
declaration has to be used.
If this is not done it will later crash when on deserialization.
---
clang/include/clang/AST/DeclCXX.h | 5 +-
.../test/Modules/ComplexExplicitSpecifier.cpp | 6758 +++++++++++++++++
2 files changed, 6761 insertions(+), 2 deletions(-)
create mode 100644 clang/test/Modules/ComplexExplicitSpecifier.cpp
diff --git a/clang/include/clang/AST/DeclCXX.h b/clang/include/clang/AST/DeclCXX.h
index dbd02ef7f8011..7728669b3bcec 100644
--- a/clang/include/clang/AST/DeclCXX.h
+++ b/clang/include/clang/AST/DeclCXX.h
@@ -2601,10 +2601,11 @@ class CXXConstructorDecl final
void anchor() override;
size_t numTrailingObjects(OverloadToken<InheritedConstructor>) const {
- return CXXConstructorDeclBits.IsInheritingConstructor;
+ return getCanonicalDecl()->CXXConstructorDeclBits.IsInheritingConstructor;
}
size_t numTrailingObjects(OverloadToken<ExplicitSpecifier>) const {
- return CXXConstructorDeclBits.HasTrailingExplicitSpecifier;
+ return getCanonicalDecl()
+ ->CXXConstructorDeclBits.HasTrailingExplicitSpecifier;
}
ExplicitSpecifier getExplicitSpecifierInternal() const {
diff --git a/clang/test/Modules/ComplexExplicitSpecifier.cpp b/clang/test/Modules/ComplexExplicitSpecifier.cpp
new file mode 100644
index 0000000000000..2f42d96e3f2bd
--- /dev/null
+++ b/clang/test/Modules/ComplexExplicitSpecifier.cpp
@@ -0,0 +1,6758 @@
+// Tests complex explicit constructor across modules.
+//
+// RUN: rm -rf %t
+// RUN: mkdir -p %t
+// RUN: split-file %s %t
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface %t/Foo.cppm \
+// RUN: -o %t/Foo.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-module-interface \
+// RUN: -fmodule-file=Foo=%t/Foo.pcm \
+// RUN: %t/Bar.cppm \
+// RUN: -o %t/Bar.pcm
+
+// RUN: %clang_cc1 -std=c++20 -emit-obj \
+// RUN: -main-file-name Bar.cppm \
+// RUN: -fmodule-file=Foo=%t/Foo.pcm \
+// RUN: -x pcm %t/Bar.pcm \
+// RUN: -o %t/Bar.o
+
+//--- Foo.cppm
+module;
+
+# 1 "includes.hpp"
+# 1 "<built-in>" 1
+# 1 "<built-in>" 3
+# 489 "<built-in>" 3
+# 1 "<command line>" 1
+# 1 "<built-in>" 2
+# 1 "includes.hpp" 2
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/concepts" 1 3
+# 34 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/concepts" 3
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 1 3
+# 48 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 3
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 1 3
+# 34 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+# 308 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+ typedef long unsigned int size_t;
+ typedef long int ptrdiff_t;
+
+
+ typedef decltype(nullptr) nullptr_t;
+
+
+#pragma GCC visibility push(default)
+
+
+ extern "C++" __attribute__ ((__noreturn__, __always_inline__))
+ inline void __terminate() noexcept
+ {
+ void terminate() noexcept __attribute__ ((__noreturn__,__cold__));
+ terminate();
+ }
+#pragma GCC visibility pop
+}
+# 341 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+ inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+namespace __gnu_cxx
+{
+ inline namespace __cxx11 __attribute__((__abi_tag__ ("cxx11"))) { }
+}
+# 534 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+#pragma GCC visibility push(default)
+
+
+
+
+ __attribute__((__always_inline__))
+ constexpr inline bool
+ __is_constant_evaluated() noexcept
+ {
+
+
+
+
+
+ return __builtin_is_constant_evaluated();
+
+
+
+ }
+#pragma GCC visibility pop
+}
+# 573 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+#pragma GCC visibility push(default)
+
+ extern "C++" __attribute__ ((__noreturn__))
+ void
+ __glibcxx_assert_fail
+ (const char* __file, int __line, const char* __function,
+ const char* __condition)
+ noexcept;
+#pragma GCC visibility pop
+}
+# 604 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+namespace std
+{
+ __attribute__((__always_inline__,__visibility__("default")))
+ inline void
+ __glibcxx_assert_fail()
+ { }
+}
+# 683 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 1 3
+# 39 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 3
+# 1 "/usr/include/features.h" 1 3 4
+# 415 "/usr/include/features.h" 3 4
+# 1 "/usr/include/features-time64.h" 1 3 4
+# 20 "/usr/include/features-time64.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 21 "/usr/include/features-time64.h" 2 3 4
+# 1 "/usr/include/bits/timesize.h" 1 3 4
+# 19 "/usr/include/bits/timesize.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 20 "/usr/include/bits/timesize.h" 2 3 4
+# 22 "/usr/include/features-time64.h" 2 3 4
+# 416 "/usr/include/features.h" 2 3 4
+# 502 "/usr/include/features.h" 3 4
+# 1 "/usr/include/stdc-predef.h" 1 3 4
+# 503 "/usr/include/features.h" 2 3 4
+# 524 "/usr/include/features.h" 3 4
+# 1 "/usr/include/sys/cdefs.h" 1 3 4
+# 730 "/usr/include/sys/cdefs.h" 3 4
+# 1 "/usr/include/bits/wordsize.h" 1 3 4
+# 731 "/usr/include/sys/cdefs.h" 2 3 4
+# 1 "/usr/include/bits/long-double.h" 1 3 4
+# 732 "/usr/include/sys/cdefs.h" 2 3 4
+# 525 "/usr/include/features.h" 2 3 4
+# 548 "/usr/include/features.h" 3 4
+# 1 "/usr/include/gnu/stubs.h" 1 3 4
+# 10 "/usr/include/gnu/stubs.h" 3 4
+# 1 "/usr/include/gnu/stubs-64.h" 1 3 4
+# 11 "/usr/include/gnu/stubs.h" 2 3 4
+# 549 "/usr/include/features.h" 2 3 4
+# 40 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/os_defines.h" 2 3
+# 684 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/cpu_defines.h" 1 3
+# 687 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+# 890 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/pstl/pstl_config.h" 1 3
+# 891 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/x86_64-pc-linux-gnu/bits/c++config.h" 2 3
+# 50 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 2 3
+# 37 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/concepts" 2 3
+# 46 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/concepts" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 1 3
+# 33 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+# 63 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 1 3
+# 48 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 3
+# 64 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+ template<typename _Tp>
+ class reference_wrapper;
+# 86 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp, _Tp __v>
+ struct integral_constant
+ {
+ static constexpr _Tp value = __v;
+ using value_type = _Tp;
+ using type = integral_constant<_Tp, __v>;
+ constexpr operator value_type() const noexcept { return value; }
+
+
+ constexpr value_type operator()() const noexcept { return value; }
+
+ };
+# 106 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<bool __v>
+ using __bool_constant = integral_constant<bool, __v>;
+
+
+
+ using true_type = __bool_constant<true>;
+
+
+ using false_type = __bool_constant<false>;
+
+
+
+
+ template<bool __v>
+ using bool_constant = __bool_constant<__v>;
+
+
+
+
+
+
+ template<bool, typename _Tp = void>
+ struct enable_if
+ { };
+
+
+ template<typename _Tp>
+ struct enable_if<true, _Tp>
+ { using type = _Tp; };
+
+
+ template<bool _Cond, typename _Tp = void>
+ using __enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+ template<bool>
+ struct __conditional
+ {
+ template<typename _Tp, typename>
+ using type = _Tp;
+ };
+
+ template<>
+ struct __conditional<false>
+ {
+ template<typename, typename _Up>
+ using type = _Up;
+ };
+
+
+ template<bool _Cond, typename _If, typename _Else>
+ using __conditional_t
+ = typename __conditional<_Cond>::template type<_If, _Else>;
+
+
+ template <typename _Type>
+ struct __type_identity
+ { using type = _Type; };
+
+ template<typename _Tp>
+ using __type_identity_t = typename __type_identity<_Tp>::type;
+
+ namespace __detail
+ {
+
+ template<typename _Tp, typename...>
+ using __first_t = _Tp;
+
+
+ template<typename... _Bn>
+ auto __or_fn(int) -> __first_t<false_type,
+ __enable_if_t<!bool(_Bn::value)>...>;
+
+ template<typename... _Bn>
+ auto __or_fn(...) -> true_type;
+
+ template<typename... _Bn>
+ auto __and_fn(int) -> __first_t<true_type,
+ __enable_if_t<bool(_Bn::value)>...>;
+
+ template<typename... _Bn>
+ auto __and_fn(...) -> false_type;
+ }
+
+
+
+
+ template<typename... _Bn>
+ struct __or_
+ : decltype(__detail::__or_fn<_Bn...>(0))
+ { };
+
+ template<typename... _Bn>
+ struct __and_
+ : decltype(__detail::__and_fn<_Bn...>(0))
+ { };
+
+ template<typename _Pp>
+ struct __not_
+ : __bool_constant<!bool(_Pp::value)>
+ { };
+
+
+
+
+
+ template<typename... _Bn>
+ inline constexpr bool __or_v = __or_<_Bn...>::value;
+ template<typename... _Bn>
+ inline constexpr bool __and_v = __and_<_Bn...>::value;
+
+ namespace __detail
+ {
+ template<typename , typename _B1, typename... _Bn>
+ struct __disjunction_impl
+ { using type = _B1; };
+
+ template<typename _B1, typename _B2, typename... _Bn>
+ struct __disjunction_impl<__enable_if_t<!bool(_B1::value)>, _B1, _B2, _Bn...>
+ { using type = typename __disjunction_impl<void, _B2, _Bn...>::type; };
+
+ template<typename , typename _B1, typename... _Bn>
+ struct __conjunction_impl
+ { using type = _B1; };
+
+ template<typename _B1, typename _B2, typename... _Bn>
+ struct __conjunction_impl<__enable_if_t<bool(_B1::value)>, _B1, _B2, _Bn...>
+ { using type = typename __conjunction_impl<void, _B2, _Bn...>::type; };
+ }
+
+
+ template<typename... _Bn>
+ struct conjunction
+ : __detail::__conjunction_impl<void, _Bn...>::type
+ { };
+
+ template<>
+ struct conjunction<>
+ : true_type
+ { };
+
+ template<typename... _Bn>
+ struct disjunction
+ : __detail::__disjunction_impl<void, _Bn...>::type
+ { };
+
+ template<>
+ struct disjunction<>
+ : false_type
+ { };
+
+ template<typename _Pp>
+ struct negation
+ : __not_<_Pp>::type
+ { };
+
+
+
+
+ template<typename... _Bn>
+ inline constexpr bool conjunction_v = conjunction<_Bn...>::value;
+
+ template<typename... _Bn>
+ inline constexpr bool disjunction_v = disjunction<_Bn...>::value;
+
+ template<typename _Pp>
+ inline constexpr bool negation_v = negation<_Pp>::value;
+
+
+
+
+
+ template<typename>
+ struct is_reference;
+ template<typename>
+ struct is_function;
+ template<typename>
+ struct is_void;
+ template<typename>
+ struct remove_cv;
+ template<typename>
+ struct is_const;
+
+
+ template<typename>
+ struct __is_array_unknown_bounds;
+
+
+
+
+ template <typename _Tp, size_t = sizeof(_Tp)>
+ constexpr true_type __is_complete_or_unbounded(__type_identity<_Tp>)
+ { return {}; }
+
+ template <typename _TypeIdentity,
+ typename _NestedType = typename _TypeIdentity::type>
+ constexpr typename __or_<
+ is_reference<_NestedType>,
+ is_function<_NestedType>,
+ is_void<_NestedType>,
+ __is_array_unknown_bounds<_NestedType>
+ >::type __is_complete_or_unbounded(_TypeIdentity)
+ { return {}; }
+
+
+ template<typename _Tp>
+ using __remove_cv_t = typename remove_cv<_Tp>::type;
+
+
+
+
+
+ template<typename _Tp>
+ struct is_void
+ : public false_type { };
+
+ template<>
+ struct is_void<void>
+ : public true_type { };
+
+ template<>
+ struct is_void<const void>
+ : public true_type { };
+
+ template<>
+ struct is_void<volatile void>
+ : public true_type { };
+
+ template<>
+ struct is_void<const volatile void>
+ : public true_type { };
+
+
+ template<typename>
+ struct __is_integral_helper
+ : public false_type { };
+
+ template<>
+ struct __is_integral_helper<bool>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<char>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<signed char>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<unsigned char>
+ : public true_type { };
+
+
+
+
+ template<>
+ struct __is_integral_helper<wchar_t>
+ : public true_type { };
+
+
+ template<>
+ struct __is_integral_helper<char8_t>
+ : public true_type { };
+
+
+ template<>
+ struct __is_integral_helper<char16_t>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<char32_t>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<short>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<unsigned short>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<int>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<unsigned int>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<long>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<unsigned long>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<long long>
+ : public true_type { };
+
+ template<>
+ struct __is_integral_helper<unsigned long long>
+ : public true_type { };
+# 460 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_integral
+ : public __is_integral_helper<__remove_cv_t<_Tp>>::type
+ { };
+
+
+ template<typename>
+ struct __is_floating_point_helper
+ : public false_type { };
+
+ template<>
+ struct __is_floating_point_helper<float>
+ : public true_type { };
+
+ template<>
+ struct __is_floating_point_helper<double>
+ : public true_type { };
+
+ template<>
+ struct __is_floating_point_helper<long double>
+ : public true_type { };
+# 520 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_floating_point
+ : public __is_floating_point_helper<__remove_cv_t<_Tp>>::type
+ { };
+
+
+
+ template<typename _Tp>
+ struct is_array
+ : public __bool_constant<__is_array(_Tp)>
+ { };
+# 545 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename>
+ struct __is_pointer_helper
+ : public false_type { };
+
+ template<typename _Tp>
+ struct __is_pointer_helper<_Tp*>
+ : public true_type { };
+
+
+ template<typename _Tp>
+ struct is_pointer
+ : public __is_pointer_helper<__remove_cv_t<_Tp>>::type
+ { };
+
+
+ template<typename>
+ struct is_lvalue_reference
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_lvalue_reference<_Tp&>
+ : public true_type { };
+
+
+ template<typename>
+ struct is_rvalue_reference
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_rvalue_reference<_Tp&&>
+ : public true_type { };
+
+
+
+ template<typename _Tp>
+ struct is_member_object_pointer
+ : public __bool_constant<__is_member_object_pointer(_Tp)>
+ { };
+# 601 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_member_function_pointer
+ : public __bool_constant<__is_member_function_pointer(_Tp)>
+ { };
+# 622 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_enum
+ : public __bool_constant<__is_enum(_Tp)>
+ { };
+
+
+ template<typename _Tp>
+ struct is_union
+ : public __bool_constant<__is_union(_Tp)>
+ { };
+
+
+ template<typename _Tp>
+ struct is_class
+ : public __bool_constant<__is_class(_Tp)>
+ { };
+
+
+
+ template<typename _Tp>
+ struct is_function
+ : public __bool_constant<__is_function(_Tp)>
+ { };
+# 661 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_null_pointer
+ : public false_type { };
+
+ template<>
+ struct is_null_pointer<std::nullptr_t>
+ : public true_type { };
+
+ template<>
+ struct is_null_pointer<const std::nullptr_t>
+ : public true_type { };
+
+ template<>
+ struct is_null_pointer<volatile std::nullptr_t>
+ : public true_type { };
+
+ template<>
+ struct is_null_pointer<const volatile std::nullptr_t>
+ : public true_type { };
+
+
+
+ template<typename _Tp>
+ struct __is_nullptr_t
+ : public is_null_pointer<_Tp>
+ { } __attribute__ ((__deprecated__ ("use '" "std::is_null_pointer" "' instead")));
+
+
+
+
+
+
+ template<typename _Tp>
+ struct is_reference
+ : public __bool_constant<__is_reference(_Tp)>
+ { };
+# 715 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_arithmetic
+ : public __or_<is_integral<_Tp>, is_floating_point<_Tp>>::type
+ { };
+
+
+ template<typename _Tp>
+ struct is_fundamental
+ : public __or_<is_arithmetic<_Tp>, is_void<_Tp>,
+ is_null_pointer<_Tp>>::type
+ { };
+
+
+
+ template<typename _Tp>
+ struct is_object
+ : public __bool_constant<__is_object(_Tp)>
+ { };
+# 741 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename>
+ struct is_member_pointer;
+
+
+ template<typename _Tp>
+ struct is_scalar
+ : public __or_<is_arithmetic<_Tp>, is_enum<_Tp>, is_pointer<_Tp>,
+ is_member_pointer<_Tp>, is_null_pointer<_Tp>>::type
+ { };
+
+
+ template<typename _Tp>
+ struct is_compound
+ : public __bool_constant<!is_fundamental<_Tp>::value> { };
+
+
+
+ template<typename _Tp>
+ struct is_member_pointer
+ : public __bool_constant<__is_member_pointer(_Tp)>
+ { };
+# 779 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename, typename>
+ struct is_same;
+
+
+ template<typename _Tp, typename... _Types>
+ using __is_one_of = __or_<is_same<_Tp, _Types>...>;
+
+
+ __extension__
+ template<typename _Tp>
+ using __is_signed_integer = __is_one_of<__remove_cv_t<_Tp>,
+ signed char, signed short, signed int, signed long,
+ signed long long
+# 804 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ >;
+
+
+ __extension__
+ template<typename _Tp>
+ using __is_unsigned_integer = __is_one_of<__remove_cv_t<_Tp>,
+ unsigned char, unsigned short, unsigned int, unsigned long,
+ unsigned long long
+# 824 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ >;
+
+
+ template<typename _Tp>
+ using __is_standard_integer
+ = __or_<__is_signed_integer<_Tp>, __is_unsigned_integer<_Tp>>;
+
+
+ template<typename...> using __void_t = void;
+
+
+
+
+
+ template<typename>
+ struct is_const
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_const<_Tp const>
+ : public true_type { };
+
+
+ template<typename>
+ struct is_volatile
+ : public false_type { };
+
+ template<typename _Tp>
+ struct is_volatile<_Tp volatile>
+ : public true_type { };
+
+
+ template<typename _Tp>
+ struct is_trivial
+ : public __bool_constant<__is_trivial(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_trivially_copyable
+ : public __bool_constant<__is_trivially_copyable(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_standard_layout
+ : public __bool_constant<__is_standard_layout(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+
+
+
+ template<typename _Tp>
+ struct
+ __attribute__ ((__deprecated__ ("use '" "is_standard_layout && is_trivial" "' instead")))
+ is_pod
+ : public __bool_constant<__is_pod(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+
+
+ template<typename _Tp>
+ struct
+ [[__deprecated__]]
+ is_literal_type
+ : public __bool_constant<__is_literal_type(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_empty
+ : public __bool_constant<__is_empty(_Tp)>
+ { };
+
+
+ template<typename _Tp>
+ struct is_polymorphic
+ : public __bool_constant<__is_polymorphic(_Tp)>
+ { };
+
+
+
+
+ template<typename _Tp>
+ struct is_final
+ : public __bool_constant<__is_final(_Tp)>
+ { };
+
+
+
+ template<typename _Tp>
+ struct is_abstract
+ : public __bool_constant<__is_abstract(_Tp)>
+ { };
+
+
+ template<typename _Tp,
+ bool = is_arithmetic<_Tp>::value>
+ struct __is_signed_helper
+ : public false_type { };
+
+ template<typename _Tp>
+ struct __is_signed_helper<_Tp, true>
+ : public __bool_constant<_Tp(-1) < _Tp(0)>
+ { };
+
+
+
+ template<typename _Tp>
+ struct is_signed
+ : public __is_signed_helper<_Tp>::type
+ { };
+
+
+ template<typename _Tp>
+ struct is_unsigned
+ : public __and_<is_arithmetic<_Tp>, __not_<is_signed<_Tp>>>::type
+ { };
+
+
+ template<typename _Tp, typename _Up = _Tp&&>
+ _Up
+ __declval(int);
+
+ template<typename _Tp>
+ _Tp
+ __declval(long);
+
+
+ template<typename _Tp>
+ auto declval() noexcept -> decltype(__declval<_Tp>(0));
+
+ template<typename>
+ struct remove_all_extents;
+
+
+ template<typename _Tp>
+ struct __is_array_known_bounds
+ : public false_type
+ { };
+
+ template<typename _Tp, size_t _Size>
+ struct __is_array_known_bounds<_Tp[_Size]>
+ : public true_type
+ { };
+
+ template<typename _Tp>
+ struct __is_array_unknown_bounds
+ : public false_type
+ { };
+
+ template<typename _Tp>
+ struct __is_array_unknown_bounds<_Tp[]>
+ : public true_type
+ { };
+# 1006 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ struct __do_is_destructible_impl
+ {
+ template<typename _Tp, typename = decltype(declval<_Tp&>().~_Tp())>
+ static true_type __test(int);
+
+ template<typename>
+ static false_type __test(...);
+ };
+
+ template<typename _Tp>
+ struct __is_destructible_impl
+ : public __do_is_destructible_impl
+ {
+ using type = decltype(__test<_Tp>(0));
+ };
+
+ template<typename _Tp,
+ bool = __or_<is_void<_Tp>,
+ __is_array_unknown_bounds<_Tp>,
+ is_function<_Tp>>::value,
+ bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+ struct __is_destructible_safe;
+
+ template<typename _Tp>
+ struct __is_destructible_safe<_Tp, false, false>
+ : public __is_destructible_impl<typename
+ remove_all_extents<_Tp>::type>::type
+ { };
+
+ template<typename _Tp>
+ struct __is_destructible_safe<_Tp, true, false>
+ : public false_type { };
+
+ template<typename _Tp>
+ struct __is_destructible_safe<_Tp, false, true>
+ : public true_type { };
+
+
+
+ template<typename _Tp>
+ struct is_destructible
+ : public __is_destructible_safe<_Tp>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+
+
+
+
+ struct __do_is_nt_destructible_impl
+ {
+ template<typename _Tp>
+ static __bool_constant<noexcept(declval<_Tp&>().~_Tp())>
+ __test(int);
+
+ template<typename>
+ static false_type __test(...);
+ };
+
+ template<typename _Tp>
+ struct __is_nt_destructible_impl
+ : public __do_is_nt_destructible_impl
+ {
+ using type = decltype(__test<_Tp>(0));
+ };
+
+ template<typename _Tp,
+ bool = __or_<is_void<_Tp>,
+ __is_array_unknown_bounds<_Tp>,
+ is_function<_Tp>>::value,
+ bool = __or_<is_reference<_Tp>, is_scalar<_Tp>>::value>
+ struct __is_nt_destructible_safe;
+
+ template<typename _Tp>
+ struct __is_nt_destructible_safe<_Tp, false, false>
+ : public __is_nt_destructible_impl<typename
+ remove_all_extents<_Tp>::type>::type
+ { };
+
+ template<typename _Tp>
+ struct __is_nt_destructible_safe<_Tp, true, false>
+ : public false_type { };
+
+ template<typename _Tp>
+ struct __is_nt_destructible_safe<_Tp, false, true>
+ : public true_type { };
+
+
+
+ template<typename _Tp>
+ struct is_nothrow_destructible
+ : public __is_nt_destructible_safe<_Tp>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename... _Args>
+ using __is_constructible_impl
+ = __bool_constant<__is_constructible(_Tp, _Args...)>;
+
+
+
+ template<typename _Tp, typename... _Args>
+ struct is_constructible
+ : public __is_constructible_impl<_Tp, _Args...>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_default_constructible
+ : public __is_constructible_impl<_Tp>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename = void>
+ struct __add_lvalue_reference_helper
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct __add_lvalue_reference_helper<_Tp, __void_t<_Tp&>>
+ { using type = _Tp&; };
+
+ template<typename _Tp>
+ using __add_lval_ref_t = typename __add_lvalue_reference_helper<_Tp>::type;
+
+
+
+ template<typename _Tp>
+ struct is_copy_constructible
+ : public __is_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename = void>
+ struct __add_rvalue_reference_helper
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct __add_rvalue_reference_helper<_Tp, __void_t<_Tp&&>>
+ { using type = _Tp&&; };
+
+ template<typename _Tp>
+ using __add_rval_ref_t = typename __add_rvalue_reference_helper<_Tp>::type;
+
+
+
+ template<typename _Tp>
+ struct is_move_constructible
+ : public __is_constructible_impl<_Tp, __add_rval_ref_t<_Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename... _Args>
+ using __is_nothrow_constructible_impl
+ = __bool_constant<__is_nothrow_constructible(_Tp, _Args...)>;
+
+
+
+ template<typename _Tp, typename... _Args>
+ struct is_nothrow_constructible
+ : public __is_nothrow_constructible_impl<_Tp, _Args...>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_nothrow_default_constructible
+ : public __is_nothrow_constructible_impl<_Tp>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_nothrow_copy_constructible
+ : public __is_nothrow_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_nothrow_move_constructible
+ : public __is_nothrow_constructible_impl<_Tp, __add_rval_ref_t<_Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename _Up>
+ using __is_assignable_impl = __bool_constant<__is_assignable(_Tp, _Up)>;
+
+
+
+ template<typename _Tp, typename _Up>
+ struct is_assignable
+ : public __is_assignable_impl<_Tp, _Up>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_copy_assignable
+ : public __is_assignable_impl<__add_lval_ref_t<_Tp>,
+ __add_lval_ref_t<const _Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_move_assignable
+ : public __is_assignable_impl<__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename _Up>
+ using __is_nothrow_assignable_impl
+ = __bool_constant<__is_nothrow_assignable(_Tp, _Up)>;
+
+
+
+ template<typename _Tp, typename _Up>
+ struct is_nothrow_assignable
+ : public __is_nothrow_assignable_impl<_Tp, _Up>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_nothrow_copy_assignable
+ : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>,
+ __add_lval_ref_t<const _Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_nothrow_move_assignable
+ : public __is_nothrow_assignable_impl<__add_lval_ref_t<_Tp>,
+ __add_rval_ref_t<_Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename... _Args>
+ using __is_trivially_constructible_impl
+ = __bool_constant<__is_trivially_constructible(_Tp, _Args...)>;
+
+
+
+ template<typename _Tp, typename... _Args>
+ struct is_trivially_constructible
+ : public __is_trivially_constructible_impl<_Tp, _Args...>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_trivially_default_constructible
+ : public __is_trivially_constructible_impl<_Tp>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ constexpr bool __is_implicitly_default_constructible_v
+ = requires (void(&__f)(_Tp)) { __f({}); };
+
+ template<typename _Tp>
+ struct __is_implicitly_default_constructible
+ : __bool_constant<__is_implicitly_default_constructible_v<_Tp>>
+ { };
+# 1351 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct is_trivially_copy_constructible
+ : public __is_trivially_constructible_impl<_Tp, __add_lval_ref_t<const _Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_trivially_move_constructible
+ : public __is_trivially_constructible_impl<_Tp, __add_rval_ref_t<_Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename _Up>
+ using __is_trivially_assignable_impl
+ = __bool_constant<__is_trivially_assignable(_Tp, _Up)>;
+
+
+
+ template<typename _Tp, typename _Up>
+ struct is_trivially_assignable
+ : public __is_trivially_assignable_impl<_Tp, _Up>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_trivially_copy_assignable
+ : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>,
+ __add_lval_ref_t<const _Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_trivially_move_assignable
+ : public __is_trivially_assignable_impl<__add_lval_ref_t<_Tp>,
+ __add_rval_ref_t<_Tp>>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_trivially_destructible
+ : public __and_<__is_destructible_safe<_Tp>,
+ __bool_constant<__has_trivial_destructor(_Tp)>>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+ template<typename _Tp>
+ struct has_virtual_destructor
+ : public __bool_constant<__has_virtual_destructor(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+
+
+ template<typename _Tp>
+ struct alignment_of
+ : public integral_constant<std::size_t, alignof(_Tp)>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename>
+ struct rank
+ : public integral_constant<std::size_t, 0> { };
+
+ template<typename _Tp, std::size_t _Size>
+ struct rank<_Tp[_Size]>
+ : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+ template<typename _Tp>
+ struct rank<_Tp[]>
+ : public integral_constant<std::size_t, 1 + rank<_Tp>::value> { };
+
+
+ template<typename, unsigned _Uint = 0>
+ struct extent
+ : public integral_constant<size_t, 0> { };
+
+ template<typename _Tp, size_t _Size>
+ struct extent<_Tp[_Size], 0>
+ : public integral_constant<size_t, _Size> { };
+
+ template<typename _Tp, unsigned _Uint, size_t _Size>
+ struct extent<_Tp[_Size], _Uint>
+ : public extent<_Tp, _Uint - 1>::type { };
+
+ template<typename _Tp>
+ struct extent<_Tp[], 0>
+ : public integral_constant<size_t, 0> { };
+
+ template<typename _Tp, unsigned _Uint>
+ struct extent<_Tp[], _Uint>
+ : public extent<_Tp, _Uint - 1>::type { };
+
+
+
+
+
+
+ template<typename _Tp, typename _Up>
+ struct is_same
+ : public __bool_constant<__is_same(_Tp, _Up)>
+ { };
+# 1491 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Base, typename _Derived>
+ struct is_base_of
+ : public __bool_constant<__is_base_of(_Base, _Derived)>
+ { };
+
+
+ template<typename _From, typename _To>
+ struct is_convertible
+ : public __bool_constant<__is_convertible(_From, _To)>
+ { };
+# 1540 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _ToElementType, typename _FromElementType>
+ using __is_array_convertible
+ = is_convertible<_FromElementType(*)[], _ToElementType(*)[]>;
+
+
+
+
+
+ template<typename _From, typename _To>
+ inline constexpr bool is_nothrow_convertible_v
+ = __is_nothrow_convertible(_From, _To);
+
+
+ template<typename _From, typename _To>
+ struct is_nothrow_convertible
+ : public bool_constant<is_nothrow_convertible_v<_From, _To>>
+ { };
+# 1600 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wc++14-extensions"
+ template<typename _Tp, typename... _Args>
+ struct __is_nothrow_new_constructible_impl
+ : __bool_constant<
+ noexcept(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))
+ >
+ { };
+
+ template<typename _Tp, typename... _Args>
+ inline constexpr bool __is_nothrow_new_constructible
+ = __and_<is_constructible<_Tp, _Args...>,
+ __is_nothrow_new_constructible_impl<_Tp, _Args...>>::value;
+#pragma GCC diagnostic pop
+
+
+
+
+ template<typename _Tp>
+ struct remove_const
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct remove_const<_Tp const>
+ { using type = _Tp; };
+
+
+ template<typename _Tp>
+ struct remove_volatile
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct remove_volatile<_Tp volatile>
+ { using type = _Tp; };
+
+
+
+ template<typename _Tp>
+ struct remove_cv
+ { using type = __remove_cv(_Tp); };
+# 1659 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct add_const
+ { using type = _Tp const; };
+
+
+ template<typename _Tp>
+ struct add_volatile
+ { using type = _Tp volatile; };
+
+
+ template<typename _Tp>
+ struct add_cv
+ { using type = _Tp const volatile; };
+
+
+
+ template<typename _Tp>
+ using remove_const_t = typename remove_const<_Tp>::type;
+
+
+ template<typename _Tp>
+ using remove_volatile_t = typename remove_volatile<_Tp>::type;
+
+
+ template<typename _Tp>
+ using remove_cv_t = typename remove_cv<_Tp>::type;
+
+
+ template<typename _Tp>
+ using add_const_t = typename add_const<_Tp>::type;
+
+
+ template<typename _Tp>
+ using add_volatile_t = typename add_volatile<_Tp>::type;
+
+
+ template<typename _Tp>
+ using add_cv_t = typename add_cv<_Tp>::type;
+# 1707 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct remove_reference
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct remove_reference<_Tp&>
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct remove_reference<_Tp&&>
+ { using type = _Tp; };
+
+
+
+ template<typename _Tp>
+ struct add_lvalue_reference
+ { using type = __add_lval_ref_t<_Tp>; };
+
+
+ template<typename _Tp>
+ struct add_rvalue_reference
+ { using type = __add_rval_ref_t<_Tp>; };
+
+
+
+ template<typename _Tp>
+ using remove_reference_t = typename remove_reference<_Tp>::type;
+
+
+ template<typename _Tp>
+ using add_lvalue_reference_t = typename add_lvalue_reference<_Tp>::type;
+
+
+ template<typename _Tp>
+ using add_rvalue_reference_t = typename add_rvalue_reference<_Tp>::type;
+
+
+
+
+
+
+
+ template<typename _Unqualified, bool _IsConst, bool _IsVol>
+ struct __cv_selector;
+
+ template<typename _Unqualified>
+ struct __cv_selector<_Unqualified, false, false>
+ { using __type = _Unqualified; };
+
+ template<typename _Unqualified>
+ struct __cv_selector<_Unqualified, false, true>
+ { using __type = volatile _Unqualified; };
+
+ template<typename _Unqualified>
+ struct __cv_selector<_Unqualified, true, false>
+ { using __type = const _Unqualified; };
+
+ template<typename _Unqualified>
+ struct __cv_selector<_Unqualified, true, true>
+ { using __type = const volatile _Unqualified; };
+
+ template<typename _Qualified, typename _Unqualified,
+ bool _IsConst = is_const<_Qualified>::value,
+ bool _IsVol = is_volatile<_Qualified>::value>
+ class __match_cv_qualifiers
+ {
+ using __match = __cv_selector<_Unqualified, _IsConst, _IsVol>;
+
+ public:
+ using __type = typename __match::__type;
+ };
+
+
+ template<typename _Tp>
+ struct __make_unsigned
+ { using __type = _Tp; };
+
+ template<>
+ struct __make_unsigned<char>
+ { using __type = unsigned char; };
+
+ template<>
+ struct __make_unsigned<signed char>
+ { using __type = unsigned char; };
+
+ template<>
+ struct __make_unsigned<short>
+ { using __type = unsigned short; };
+
+ template<>
+ struct __make_unsigned<int>
+ { using __type = unsigned int; };
+
+ template<>
+ struct __make_unsigned<long>
+ { using __type = unsigned long; };
+
+ template<>
+ struct __make_unsigned<long long>
+ { using __type = unsigned long long; };
+# 1834 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp,
+ bool _IsInt = is_integral<_Tp>::value,
+ bool _IsEnum = __is_enum(_Tp)>
+ class __make_unsigned_selector;
+
+ template<typename _Tp>
+ class __make_unsigned_selector<_Tp, true, false>
+ {
+ using __unsigned_type
+ = typename __make_unsigned<__remove_cv_t<_Tp>>::__type;
+
+ public:
+ using __type
+ = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
+ };
+
+ class __make_unsigned_selector_base
+ {
+ protected:
+ template<typename...> struct _List { };
+
+ template<typename _Tp, typename... _Up>
+ struct _List<_Tp, _Up...> : _List<_Up...>
+ { static constexpr size_t __size = sizeof(_Tp); };
+
+ template<size_t _Sz, typename _Tp, bool = (_Sz <= _Tp::__size)>
+ struct __select;
+
+ template<size_t _Sz, typename _Uint, typename... _UInts>
+ struct __select<_Sz, _List<_Uint, _UInts...>, true>
+ { using __type = _Uint; };
+
+ template<size_t _Sz, typename _Uint, typename... _UInts>
+ struct __select<_Sz, _List<_Uint, _UInts...>, false>
+ : __select<_Sz, _List<_UInts...>>
+ { };
+ };
+
+
+ template<typename _Tp>
+ class __make_unsigned_selector<_Tp, false, true>
+ : __make_unsigned_selector_base
+ {
+
+ using _UInts = _List<unsigned char, unsigned short, unsigned int,
+ unsigned long, unsigned long long>;
+
+ using __unsigned_type = typename __select<sizeof(_Tp), _UInts>::__type;
+
+ public:
+ using __type
+ = typename __match_cv_qualifiers<_Tp, __unsigned_type>::__type;
+ };
+
+
+
+
+
+ template<>
+ struct __make_unsigned<wchar_t>
+ {
+ using __type
+ = typename __make_unsigned_selector<wchar_t, false, true>::__type;
+ };
+
+
+ template<>
+ struct __make_unsigned<char8_t>
+ {
+ using __type
+ = typename __make_unsigned_selector<char8_t, false, true>::__type;
+ };
+
+
+ template<>
+ struct __make_unsigned<char16_t>
+ {
+ using __type
+ = typename __make_unsigned_selector<char16_t, false, true>::__type;
+ };
+
+ template<>
+ struct __make_unsigned<char32_t>
+ {
+ using __type
+ = typename __make_unsigned_selector<char32_t, false, true>::__type;
+ };
+
+
+
+
+
+
+ template<typename _Tp>
+ struct make_unsigned
+ { using type = typename __make_unsigned_selector<_Tp>::__type; };
+
+
+ template<> struct make_unsigned<bool>;
+ template<> struct make_unsigned<bool const>;
+ template<> struct make_unsigned<bool volatile>;
+ template<> struct make_unsigned<bool const volatile>;
+
+
+
+
+ template<typename _Tp>
+ struct __make_signed
+ { using __type = _Tp; };
+
+ template<>
+ struct __make_signed<char>
+ { using __type = signed char; };
+
+ template<>
+ struct __make_signed<unsigned char>
+ { using __type = signed char; };
+
+ template<>
+ struct __make_signed<unsigned short>
+ { using __type = signed short; };
+
+ template<>
+ struct __make_signed<unsigned int>
+ { using __type = signed int; };
+
+ template<>
+ struct __make_signed<unsigned long>
+ { using __type = signed long; };
+
+ template<>
+ struct __make_signed<unsigned long long>
+ { using __type = signed long long; };
+# 1994 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp,
+ bool _IsInt = is_integral<_Tp>::value,
+ bool _IsEnum = __is_enum(_Tp)>
+ class __make_signed_selector;
+
+ template<typename _Tp>
+ class __make_signed_selector<_Tp, true, false>
+ {
+ using __signed_type
+ = typename __make_signed<__remove_cv_t<_Tp>>::__type;
+
+ public:
+ using __type
+ = typename __match_cv_qualifiers<_Tp, __signed_type>::__type;
+ };
+
+
+ template<typename _Tp>
+ class __make_signed_selector<_Tp, false, true>
+ {
+ using __unsigned_type = typename __make_unsigned_selector<_Tp>::__type;
+
+ public:
+ using __type = typename __make_signed_selector<__unsigned_type>::__type;
+ };
+
+
+
+
+
+ template<>
+ struct __make_signed<wchar_t>
+ {
+ using __type
+ = typename __make_signed_selector<wchar_t, false, true>::__type;
+ };
+
+
+ template<>
+ struct __make_signed<char8_t>
+ {
+ using __type
+ = typename __make_signed_selector<char8_t, false, true>::__type;
+ };
+
+
+ template<>
+ struct __make_signed<char16_t>
+ {
+ using __type
+ = typename __make_signed_selector<char16_t, false, true>::__type;
+ };
+
+ template<>
+ struct __make_signed<char32_t>
+ {
+ using __type
+ = typename __make_signed_selector<char32_t, false, true>::__type;
+ };
+
+
+
+
+
+
+ template<typename _Tp>
+ struct make_signed
+ { using type = typename __make_signed_selector<_Tp>::__type; };
+
+
+ template<> struct make_signed<bool>;
+ template<> struct make_signed<bool const>;
+ template<> struct make_signed<bool volatile>;
+ template<> struct make_signed<bool const volatile>;
+
+
+
+ template<typename _Tp>
+ using make_signed_t = typename make_signed<_Tp>::type;
+
+
+ template<typename _Tp>
+ using make_unsigned_t = typename make_unsigned<_Tp>::type;
+
+
+
+
+
+ template<typename _Tp>
+ struct remove_extent
+ { using type = _Tp; };
+
+ template<typename _Tp, std::size_t _Size>
+ struct remove_extent<_Tp[_Size]>
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct remove_extent<_Tp[]>
+ { using type = _Tp; };
+
+
+ template<typename _Tp>
+ struct remove_all_extents
+ { using type = _Tp; };
+
+ template<typename _Tp, std::size_t _Size>
+ struct remove_all_extents<_Tp[_Size]>
+ { using type = typename remove_all_extents<_Tp>::type; };
+
+ template<typename _Tp>
+ struct remove_all_extents<_Tp[]>
+ { using type = typename remove_all_extents<_Tp>::type; };
+
+
+
+ template<typename _Tp>
+ using remove_extent_t = typename remove_extent<_Tp>::type;
+
+
+ template<typename _Tp>
+ using remove_all_extents_t = typename remove_all_extents<_Tp>::type;
+
+
+
+
+
+
+ template<typename _Tp>
+ struct remove_pointer
+ { using type = __remove_pointer(_Tp); };
+# 2139 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp, typename = void>
+ struct __add_pointer_helper
+ { using type = _Tp; };
+
+ template<typename _Tp>
+ struct __add_pointer_helper<_Tp, __void_t<_Tp*>>
+ { using type = _Tp*; };
+
+
+ template<typename _Tp>
+ struct add_pointer
+ : public __add_pointer_helper<_Tp>
+ { };
+
+ template<typename _Tp>
+ struct add_pointer<_Tp&>
+ { using type = _Tp*; };
+
+ template<typename _Tp>
+ struct add_pointer<_Tp&&>
+ { using type = _Tp*; };
+
+
+
+ template<typename _Tp>
+ using remove_pointer_t = typename remove_pointer<_Tp>::type;
+
+
+ template<typename _Tp>
+ using add_pointer_t = typename add_pointer<_Tp>::type;
+
+
+ template<std::size_t _Len>
+ struct __aligned_storage_msa
+ {
+ union __type
+ {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__)) { } __align;
+ };
+ };
+# 2194 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<std::size_t _Len, std::size_t _Align =
+ __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+ struct
+
+ aligned_storage
+ {
+ union type
+ {
+ unsigned char __data[_Len];
+ struct __attribute__((__aligned__((_Align)))) { } __align;
+ };
+ };
+
+ template <typename... _Types>
+ struct __strictest_alignment
+ {
+ static const size_t _S_alignment = 0;
+ static const size_t _S_size = 0;
+ };
+
+ template <typename _Tp, typename... _Types>
+ struct __strictest_alignment<_Tp, _Types...>
+ {
+ static const size_t _S_alignment =
+ alignof(_Tp) > __strictest_alignment<_Types...>::_S_alignment
+ ? alignof(_Tp) : __strictest_alignment<_Types...>::_S_alignment;
+ static const size_t _S_size =
+ sizeof(_Tp) > __strictest_alignment<_Types...>::_S_size
+ ? sizeof(_Tp) : __strictest_alignment<_Types...>::_S_size;
+ };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+# 2240 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template <size_t _Len, typename... _Types>
+ struct
+
+ aligned_union
+ {
+ private:
+ static_assert(sizeof...(_Types) != 0, "At least one type is required");
+
+ using __strictest = __strictest_alignment<_Types...>;
+ static const size_t _S_len = _Len > __strictest::_S_size
+ ? _Len : __strictest::_S_size;
+ public:
+
+ static const size_t alignment_value = __strictest::_S_alignment;
+
+ using type = typename aligned_storage<_S_len, alignment_value>::type;
+ };
+
+ template <size_t _Len, typename... _Types>
+ const size_t aligned_union<_Len, _Types...>::alignment_value;
+#pragma GCC diagnostic pop
+
+
+
+
+
+ template<typename _Up>
+ struct __decay_selector
+ : __conditional_t<is_const<const _Up>::value,
+ remove_cv<_Up>,
+ add_pointer<_Up>>
+ { };
+
+ template<typename _Up, size_t _Nm>
+ struct __decay_selector<_Up[_Nm]>
+ { using type = _Up*; };
+
+ template<typename _Up>
+ struct __decay_selector<_Up[]>
+ { using type = _Up*; };
+
+
+
+
+ template<typename _Tp>
+ struct decay
+ { using type = typename __decay_selector<_Tp>::type; };
+
+ template<typename _Tp>
+ struct decay<_Tp&>
+ { using type = typename __decay_selector<_Tp>::type; };
+
+ template<typename _Tp>
+ struct decay<_Tp&&>
+ { using type = typename __decay_selector<_Tp>::type; };
+
+
+
+
+ template<typename _Tp>
+ struct __strip_reference_wrapper
+ {
+ using __type = _Tp;
+ };
+
+ template<typename _Tp>
+ struct __strip_reference_wrapper<reference_wrapper<_Tp> >
+ {
+ using __type = _Tp&;
+ };
+
+
+ template<typename _Tp>
+ using __decay_t = typename decay<_Tp>::type;
+
+ template<typename _Tp>
+ using __decay_and_strip = __strip_reference_wrapper<__decay_t<_Tp>>;
+
+
+
+
+
+ template<typename... _Cond>
+ using _Require = __enable_if_t<__and_<_Cond...>::value>;
+
+
+ template<typename _Tp>
+ using __remove_cvref_t
+ = typename remove_cv<typename remove_reference<_Tp>::type>::type;
+
+
+
+
+ template<bool _Cond, typename _Iftrue, typename _Iffalse>
+ struct conditional
+ { using type = _Iftrue; };
+
+
+ template<typename _Iftrue, typename _Iffalse>
+ struct conditional<false, _Iftrue, _Iffalse>
+ { using type = _Iffalse; };
+
+
+ template<typename... _Tp>
+ struct common_type;
+# 2355 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct __success_type
+ { using type = _Tp; };
+
+ struct __failure_type
+ { };
+
+ struct __do_common_type_impl
+ {
+ template<typename _Tp, typename _Up>
+ using __cond_t
+ = decltype(true ? std::declval<_Tp>() : std::declval<_Up>());
+
+
+
+ template<typename _Tp, typename _Up>
+ static __success_type<__decay_t<__cond_t<_Tp, _Up>>>
+ _S_test(int);
+
+
+
+
+ template<typename _Tp, typename _Up>
+ static __success_type<__remove_cvref_t<__cond_t<const _Tp&, const _Up&>>>
+ _S_test_2(int);
+
+
+ template<typename, typename>
+ static __failure_type
+ _S_test_2(...);
+
+ template<typename _Tp, typename _Up>
+ static decltype(_S_test_2<_Tp, _Up>(0))
+ _S_test(...);
+ };
+
+
+ template<>
+ struct common_type<>
+ { };
+
+
+ template<typename _Tp0>
+ struct common_type<_Tp0>
+ : public common_type<_Tp0, _Tp0>
+ { };
+
+
+ template<typename _Tp1, typename _Tp2,
+ typename _Dp1 = __decay_t<_Tp1>, typename _Dp2 = __decay_t<_Tp2>>
+ struct __common_type_impl
+ {
+
+
+ using type = common_type<_Dp1, _Dp2>;
+ };
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_type_impl<_Tp1, _Tp2, _Tp1, _Tp2>
+ : private __do_common_type_impl
+ {
+
+
+ using type = decltype(_S_test<_Tp1, _Tp2>(0));
+ };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct common_type<_Tp1, _Tp2>
+ : public __common_type_impl<_Tp1, _Tp2>::type
+ { };
+
+ template<typename...>
+ struct __common_type_pack
+ { };
+
+ template<typename, typename, typename = void>
+ struct __common_type_fold;
+
+
+ template<typename _Tp1, typename _Tp2, typename... _Rp>
+ struct common_type<_Tp1, _Tp2, _Rp...>
+ : public __common_type_fold<common_type<_Tp1, _Tp2>,
+ __common_type_pack<_Rp...>>
+ { };
+
+
+
+
+ template<typename _CTp, typename... _Rp>
+ struct __common_type_fold<_CTp, __common_type_pack<_Rp...>,
+ __void_t<typename _CTp::type>>
+ : public common_type<typename _CTp::type, _Rp...>
+ { };
+
+
+ template<typename _CTp, typename _Rp>
+ struct __common_type_fold<_CTp, _Rp, void>
+ { };
+
+ template<typename _Tp, bool = __is_enum(_Tp)>
+ struct __underlying_type_impl
+ {
+ using type = __underlying_type(_Tp);
+ };
+
+ template<typename _Tp>
+ struct __underlying_type_impl<_Tp, false>
+ { };
+
+
+
+ template<typename _Tp>
+ struct underlying_type
+ : public __underlying_type_impl<_Tp>
+ { };
+
+
+ template<typename _Tp>
+ struct __declval_protector
+ {
+ static const bool __stop = false;
+ };
+
+
+
+
+
+
+ template<typename _Tp>
+ auto declval() noexcept -> decltype(__declval<_Tp>(0))
+ {
+ static_assert(__declval_protector<_Tp>::__stop,
+ "declval() must not be used!");
+ return __declval<_Tp>(0);
+ }
+
+
+ template<typename _Signature>
+ struct result_of;
+
+
+
+
+ struct __invoke_memfun_ref { };
+ struct __invoke_memfun_deref { };
+ struct __invoke_memobj_ref { };
+ struct __invoke_memobj_deref { };
+ struct __invoke_other { };
+
+
+ template<typename _Tp, typename _Tag>
+ struct __result_of_success : __success_type<_Tp>
+ { using __invoke_type = _Tag; };
+
+
+ struct __result_of_memfun_ref_impl
+ {
+ template<typename _Fp, typename _Tp1, typename... _Args>
+ static __result_of_success<decltype(
+ (std::declval<_Tp1>().*std::declval<_Fp>())(std::declval<_Args>()...)
+ ), __invoke_memfun_ref> _S_test(int);
+
+ template<typename...>
+ static __failure_type _S_test(...);
+ };
+
+ template<typename _MemPtr, typename _Arg, typename... _Args>
+ struct __result_of_memfun_ref
+ : private __result_of_memfun_ref_impl
+ {
+ using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0));
+ };
+
+
+ struct __result_of_memfun_deref_impl
+ {
+ template<typename _Fp, typename _Tp1, typename... _Args>
+ static __result_of_success<decltype(
+ ((*std::declval<_Tp1>()).*std::declval<_Fp>())(std::declval<_Args>()...)
+ ), __invoke_memfun_deref> _S_test(int);
+
+ template<typename...>
+ static __failure_type _S_test(...);
+ };
+
+ template<typename _MemPtr, typename _Arg, typename... _Args>
+ struct __result_of_memfun_deref
+ : private __result_of_memfun_deref_impl
+ {
+ using type = decltype(_S_test<_MemPtr, _Arg, _Args...>(0));
+ };
+
+
+ struct __result_of_memobj_ref_impl
+ {
+ template<typename _Fp, typename _Tp1>
+ static __result_of_success<decltype(
+ std::declval<_Tp1>().*std::declval<_Fp>()
+ ), __invoke_memobj_ref> _S_test(int);
+
+ template<typename, typename>
+ static __failure_type _S_test(...);
+ };
+
+ template<typename _MemPtr, typename _Arg>
+ struct __result_of_memobj_ref
+ : private __result_of_memobj_ref_impl
+ {
+ using type = decltype(_S_test<_MemPtr, _Arg>(0));
+ };
+
+
+ struct __result_of_memobj_deref_impl
+ {
+ template<typename _Fp, typename _Tp1>
+ static __result_of_success<decltype(
+ (*std::declval<_Tp1>()).*std::declval<_Fp>()
+ ), __invoke_memobj_deref> _S_test(int);
+
+ template<typename, typename>
+ static __failure_type _S_test(...);
+ };
+
+ template<typename _MemPtr, typename _Arg>
+ struct __result_of_memobj_deref
+ : private __result_of_memobj_deref_impl
+ {
+ using type = decltype(_S_test<_MemPtr, _Arg>(0));
+ };
+
+ template<typename _MemPtr, typename _Arg>
+ struct __result_of_memobj;
+
+ template<typename _Res, typename _Class, typename _Arg>
+ struct __result_of_memobj<_Res _Class::*, _Arg>
+ {
+ using _Argval = __remove_cvref_t<_Arg>;
+ using _MemPtr = _Res _Class::*;
+ using type = typename __conditional_t<__or_<is_same<_Argval, _Class>,
+ is_base_of<_Class, _Argval>>::value,
+ __result_of_memobj_ref<_MemPtr, _Arg>,
+ __result_of_memobj_deref<_MemPtr, _Arg>
+ >::type;
+ };
+
+ template<typename _MemPtr, typename _Arg, typename... _Args>
+ struct __result_of_memfun;
+
+ template<typename _Res, typename _Class, typename _Arg, typename... _Args>
+ struct __result_of_memfun<_Res _Class::*, _Arg, _Args...>
+ {
+ using _Argval = typename remove_reference<_Arg>::type;
+ using _MemPtr = _Res _Class::*;
+ using type = typename __conditional_t<is_base_of<_Class, _Argval>::value,
+ __result_of_memfun_ref<_MemPtr, _Arg, _Args...>,
+ __result_of_memfun_deref<_MemPtr, _Arg, _Args...>
+ >::type;
+ };
+
+
+
+
+
+
+ template<typename _Tp, typename _Up = __remove_cvref_t<_Tp>>
+ struct __inv_unwrap
+ {
+ using type = _Tp;
+ };
+
+ template<typename _Tp, typename _Up>
+ struct __inv_unwrap<_Tp, reference_wrapper<_Up>>
+ {
+ using type = _Up&;
+ };
+
+ template<bool, bool, typename _Functor, typename... _ArgTypes>
+ struct __result_of_impl
+ {
+ using type = __failure_type;
+ };
+
+ template<typename _MemPtr, typename _Arg>
+ struct __result_of_impl<true, false, _MemPtr, _Arg>
+ : public __result_of_memobj<__decay_t<_MemPtr>,
+ typename __inv_unwrap<_Arg>::type>
+ { };
+
+ template<typename _MemPtr, typename _Arg, typename... _Args>
+ struct __result_of_impl<false, true, _MemPtr, _Arg, _Args...>
+ : public __result_of_memfun<__decay_t<_MemPtr>,
+ typename __inv_unwrap<_Arg>::type, _Args...>
+ { };
+
+
+ struct __result_of_other_impl
+ {
+ template<typename _Fn, typename... _Args>
+ static __result_of_success<decltype(
+ std::declval<_Fn>()(std::declval<_Args>()...)
+ ), __invoke_other> _S_test(int);
+
+ template<typename...>
+ static __failure_type _S_test(...);
+ };
+
+ template<typename _Functor, typename... _ArgTypes>
+ struct __result_of_impl<false, false, _Functor, _ArgTypes...>
+ : private __result_of_other_impl
+ {
+ using type = decltype(_S_test<_Functor, _ArgTypes...>(0));
+ };
+
+
+ template<typename _Functor, typename... _ArgTypes>
+ struct __invoke_result
+ : public __result_of_impl<
+ is_member_object_pointer<
+ typename remove_reference<_Functor>::type
+ >::value,
+ is_member_function_pointer<
+ typename remove_reference<_Functor>::type
+ >::value,
+ _Functor, _ArgTypes...
+ >::type
+ { };
+
+
+ template<typename _Fn, typename... _Args>
+ using __invoke_result_t = typename __invoke_result<_Fn, _Args...>::type;
+
+
+ template<typename _Functor, typename... _ArgTypes>
+ struct result_of<_Functor(_ArgTypes...)>
+ : public __invoke_result<_Functor, _ArgTypes...>
+ { } __attribute__ ((__deprecated__ ("use '" "std::invoke_result" "' instead")));
+
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
+
+ template<size_t _Len, size_t _Align =
+ __alignof__(typename __aligned_storage_msa<_Len>::__type)>
+ using aligned_storage_t = typename aligned_storage<_Len, _Align>::type;
+
+ template <size_t _Len, typename... _Types>
+ using aligned_union_t = typename aligned_union<_Len, _Types...>::type;
+#pragma GCC diagnostic pop
+
+
+ template<typename _Tp>
+ using decay_t = typename decay<_Tp>::type;
+
+
+ template<bool _Cond, typename _Tp = void>
+ using enable_if_t = typename enable_if<_Cond, _Tp>::type;
+
+
+ template<bool _Cond, typename _Iftrue, typename _Iffalse>
+ using conditional_t = typename conditional<_Cond, _Iftrue, _Iffalse>::type;
+
+
+ template<typename... _Tp>
+ using common_type_t = typename common_type<_Tp...>::type;
+
+
+ template<typename _Tp>
+ using underlying_type_t = typename underlying_type<_Tp>::type;
+
+
+ template<typename _Tp>
+ using result_of_t = typename result_of<_Tp>::type;
+
+
+
+
+ template<typename...> using void_t = void;
+# 2742 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Def, template<typename...> class _Op, typename... _Args>
+ struct __detected_or
+ {
+ using type = _Def;
+ using __is_detected = false_type;
+ };
+
+
+ template<typename _Def, template<typename...> class _Op, typename... _Args>
+ requires requires { typename _Op<_Args...>; }
+ struct __detected_or<_Def, _Op, _Args...>
+ {
+ using type = _Op<_Args...>;
+ using __is_detected = true_type;
+ };
+# 2782 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Default, template<typename...> class _Op,
+ typename... _Args>
+ using __detected_or_t
+ = typename __detected_or<_Default, _Op, _Args...>::type;
+# 2801 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template <typename _Tp>
+ struct __is_swappable;
+
+ template <typename _Tp>
+ struct __is_nothrow_swappable;
+
+ template<typename>
+ struct __is_tuple_like_impl : false_type
+ { };
+
+
+ template<typename _Tp>
+ struct __is_tuple_like
+ : public __is_tuple_like_impl<__remove_cvref_t<_Tp>>::type
+ { };
+
+
+ template<typename _Tp>
+ constexpr
+ inline
+ _Require<__not_<__is_tuple_like<_Tp>>,
+ is_move_constructible<_Tp>,
+ is_move_assignable<_Tp>>
+ swap(_Tp&, _Tp&)
+ noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+ is_nothrow_move_assignable<_Tp>>::value);
+
+ template<typename _Tp, size_t _Nm>
+ constexpr
+ inline
+ __enable_if_t<__is_swappable<_Tp>::value>
+ swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+ noexcept(__is_nothrow_swappable<_Tp>::value);
+
+
+ namespace __swappable_details {
+ using std::swap;
+
+ struct __do_is_swappable_impl
+ {
+ template<typename _Tp, typename
+ = decltype(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))>
+ static true_type __test(int);
+
+ template<typename>
+ static false_type __test(...);
+ };
+
+ struct __do_is_nothrow_swappable_impl
+ {
+ template<typename _Tp>
+ static __bool_constant<
+ noexcept(swap(std::declval<_Tp&>(), std::declval<_Tp&>()))
+ > __test(int);
+
+ template<typename>
+ static false_type __test(...);
+ };
+
+ }
+
+ template<typename _Tp>
+ struct __is_swappable_impl
+ : public __swappable_details::__do_is_swappable_impl
+ {
+ using type = decltype(__test<_Tp>(0));
+ };
+
+ template<typename _Tp>
+ struct __is_nothrow_swappable_impl
+ : public __swappable_details::__do_is_nothrow_swappable_impl
+ {
+ using type = decltype(__test<_Tp>(0));
+ };
+
+ template<typename _Tp>
+ struct __is_swappable
+ : public __is_swappable_impl<_Tp>::type
+ { };
+
+ template<typename _Tp>
+ struct __is_nothrow_swappable
+ : public __is_nothrow_swappable_impl<_Tp>::type
+ { };
+
+
+
+
+
+
+ template<typename _Tp>
+ struct is_swappable
+ : public __is_swappable_impl<_Tp>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp>
+ struct is_nothrow_swappable
+ : public __is_nothrow_swappable_impl<_Tp>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+ template<typename _Tp>
+ inline constexpr bool is_swappable_v =
+ is_swappable<_Tp>::value;
+
+
+ template<typename _Tp>
+ inline constexpr bool is_nothrow_swappable_v =
+ is_nothrow_swappable<_Tp>::value;
+
+
+
+ namespace __swappable_with_details {
+ using std::swap;
+
+ struct __do_is_swappable_with_impl
+ {
+ template<typename _Tp, typename _Up, typename
+ = decltype(swap(std::declval<_Tp>(), std::declval<_Up>())),
+ typename
+ = decltype(swap(std::declval<_Up>(), std::declval<_Tp>()))>
+ static true_type __test(int);
+
+ template<typename, typename>
+ static false_type __test(...);
+ };
+
+ struct __do_is_nothrow_swappable_with_impl
+ {
+ template<typename _Tp, typename _Up>
+ static __bool_constant<
+ noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()))
+ &&
+ noexcept(swap(std::declval<_Up>(), std::declval<_Tp>()))
+ > __test(int);
+
+ template<typename, typename>
+ static false_type __test(...);
+ };
+
+ }
+
+ template<typename _Tp, typename _Up>
+ struct __is_swappable_with_impl
+ : public __swappable_with_details::__do_is_swappable_with_impl
+ {
+ using type = decltype(__test<_Tp, _Up>(0));
+ };
+
+
+ template<typename _Tp>
+ struct __is_swappable_with_impl<_Tp&, _Tp&>
+ : public __swappable_details::__do_is_swappable_impl
+ {
+ using type = decltype(__test<_Tp&>(0));
+ };
+
+ template<typename _Tp, typename _Up>
+ struct __is_nothrow_swappable_with_impl
+ : public __swappable_with_details::__do_is_nothrow_swappable_with_impl
+ {
+ using type = decltype(__test<_Tp, _Up>(0));
+ };
+
+
+ template<typename _Tp>
+ struct __is_nothrow_swappable_with_impl<_Tp&, _Tp&>
+ : public __swappable_details::__do_is_nothrow_swappable_impl
+ {
+ using type = decltype(__test<_Tp&>(0));
+ };
+
+
+
+ template<typename _Tp, typename _Up>
+ struct is_swappable_with
+ : public __is_swappable_with_impl<_Tp, _Up>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "first template argument must be a complete class or an unbounded array");
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}),
+ "second template argument must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Tp, typename _Up>
+ struct is_nothrow_swappable_with
+ : public __is_nothrow_swappable_with_impl<_Tp, _Up>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "first template argument must be a complete class or an unbounded array");
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Up>{}),
+ "second template argument must be a complete class or an unbounded array");
+ };
+
+
+
+ template<typename _Tp, typename _Up>
+ inline constexpr bool is_swappable_with_v =
+ is_swappable_with<_Tp, _Up>::value;
+
+
+ template<typename _Tp, typename _Up>
+ inline constexpr bool is_nothrow_swappable_with_v =
+ is_nothrow_swappable_with<_Tp, _Up>::value;
+# 3023 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Result, typename _Ret,
+ bool = is_void<_Ret>::value, typename = void>
+ struct __is_invocable_impl
+ : false_type
+ {
+ using __nothrow_conv = false_type;
+ };
+
+
+ template<typename _Result, typename _Ret>
+ struct __is_invocable_impl<_Result, _Ret,
+ true,
+ __void_t<typename _Result::type>>
+ : true_type
+ {
+ using __nothrow_conv = true_type;
+ };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+
+ template<typename _Result, typename _Ret>
+ struct __is_invocable_impl<_Result, _Ret,
+ false,
+ __void_t<typename _Result::type>>
+ {
+ private:
+
+ using _Res_t = typename _Result::type;
+
+
+
+ static _Res_t _S_get() noexcept;
+
+
+ template<typename _Tp>
+ static void _S_conv(__type_identity_t<_Tp>) noexcept;
+
+
+ template<typename _Tp,
+ bool _Nothrow = noexcept(_S_conv<_Tp>(_S_get())),
+ typename = decltype(_S_conv<_Tp>(_S_get())),
+
+ bool _Dangle = __reference_converts_from_temporary(_Tp, _Res_t)
+
+
+
+ >
+ static __bool_constant<_Nothrow && !_Dangle>
+ _S_test(int);
+
+ template<typename _Tp, bool = false>
+ static false_type
+ _S_test(...);
+
+ public:
+
+ using type = decltype(_S_test<_Ret, true>(1));
+
+
+ using __nothrow_conv = decltype(_S_test<_Ret>(1));
+ };
+#pragma GCC diagnostic pop
+
+ template<typename _Fn, typename... _ArgTypes>
+ struct __is_invocable
+ : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
+ { };
+
+ template<typename _Fn, typename _Tp, typename... _Args>
+ constexpr bool __call_is_nt(__invoke_memfun_ref)
+ {
+ using _Up = typename __inv_unwrap<_Tp>::type;
+ return noexcept((std::declval<_Up>().*std::declval<_Fn>())(
+ std::declval<_Args>()...));
+ }
+
+ template<typename _Fn, typename _Tp, typename... _Args>
+ constexpr bool __call_is_nt(__invoke_memfun_deref)
+ {
+ return noexcept(((*std::declval<_Tp>()).*std::declval<_Fn>())(
+ std::declval<_Args>()...));
+ }
+
+ template<typename _Fn, typename _Tp>
+ constexpr bool __call_is_nt(__invoke_memobj_ref)
+ {
+ using _Up = typename __inv_unwrap<_Tp>::type;
+ return noexcept(std::declval<_Up>().*std::declval<_Fn>());
+ }
+
+ template<typename _Fn, typename _Tp>
+ constexpr bool __call_is_nt(__invoke_memobj_deref)
+ {
+ return noexcept((*std::declval<_Tp>()).*std::declval<_Fn>());
+ }
+
+ template<typename _Fn, typename... _Args>
+ constexpr bool __call_is_nt(__invoke_other)
+ {
+ return noexcept(std::declval<_Fn>()(std::declval<_Args>()...));
+ }
+
+ template<typename _Result, typename _Fn, typename... _Args>
+ struct __call_is_nothrow
+ : __bool_constant<
+ std::__call_is_nt<_Fn, _Args...>(typename _Result::__invoke_type{})
+ >
+ { };
+
+ template<typename _Fn, typename... _Args>
+ using __call_is_nothrow_
+ = __call_is_nothrow<__invoke_result<_Fn, _Args...>, _Fn, _Args...>;
+
+
+ template<typename _Fn, typename... _Args>
+ struct __is_nothrow_invocable
+ : __and_<__is_invocable<_Fn, _Args...>,
+ __call_is_nothrow_<_Fn, _Args...>>::type
+ { };
+
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wctor-dtor-privacy"
+ struct __nonesuchbase {};
+ struct __nonesuch : private __nonesuchbase {
+ ~__nonesuch() = delete;
+ __nonesuch(__nonesuch const&) = delete;
+ void operator=(__nonesuch const&) = delete;
+ };
+#pragma GCC diagnostic pop
+
+
+
+
+ template<typename _Functor, typename... _ArgTypes>
+ struct invoke_result
+ : public __invoke_result<_Functor, _ArgTypes...>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Functor>{}),
+ "_Functor must be a complete class or an unbounded array");
+ static_assert((std::__is_complete_or_unbounded(
+ __type_identity<_ArgTypes>{}) && ...),
+ "each argument type must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Fn, typename... _Args>
+ using invoke_result_t = typename invoke_result<_Fn, _Args...>::type;
+
+
+ template<typename _Fn, typename... _ArgTypes>
+ struct is_invocable
+ : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+ static_assert((std::__is_complete_or_unbounded(
+ __type_identity<_ArgTypes>{}) && ...),
+ "each argument type must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Ret, typename _Fn, typename... _ArgTypes>
+ struct is_invocable_r
+ : __is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+ static_assert((std::__is_complete_or_unbounded(
+ __type_identity<_ArgTypes>{}) && ...),
+ "each argument type must be a complete class or an unbounded array");
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
+ "_Ret must be a complete class or an unbounded array");
+ };
+
+
+ template<typename _Fn, typename... _ArgTypes>
+ struct is_nothrow_invocable
+ : __and_<__is_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, void>,
+ __call_is_nothrow_<_Fn, _ArgTypes...>>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+ static_assert((std::__is_complete_or_unbounded(
+ __type_identity<_ArgTypes>{}) && ...),
+ "each argument type must be a complete class or an unbounded array");
+ };
+
+
+
+
+
+ template<typename _Result, typename _Ret>
+ using __is_nt_invocable_impl
+ = typename __is_invocable_impl<_Result, _Ret>::__nothrow_conv;
+
+
+
+ template<typename _Ret, typename _Fn, typename... _ArgTypes>
+ struct is_nothrow_invocable_r
+ : __and_<__is_nt_invocable_impl<__invoke_result<_Fn, _ArgTypes...>, _Ret>,
+ __call_is_nothrow_<_Fn, _ArgTypes...>>::type
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Fn>{}),
+ "_Fn must be a complete class or an unbounded array");
+ static_assert((std::__is_complete_or_unbounded(
+ __type_identity<_ArgTypes>{}) && ...),
+ "each argument type must be a complete class or an unbounded array");
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Ret>{}),
+ "_Ret must be a complete class or an unbounded array");
+ };
+# 3251 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+template <typename _Tp>
+ inline constexpr bool is_void_v = is_void<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_null_pointer_v = is_null_pointer<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_integral_v = is_integral<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
+
+
+template <typename _Tp>
+ inline constexpr bool is_array_v = __is_array(_Tp);
+# 3272 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+template <typename _Tp>
+ inline constexpr bool is_pointer_v = is_pointer<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_lvalue_reference_v = false;
+template <typename _Tp>
+ inline constexpr bool is_lvalue_reference_v<_Tp&> = true;
+template <typename _Tp>
+ inline constexpr bool is_rvalue_reference_v = false;
+template <typename _Tp>
+ inline constexpr bool is_rvalue_reference_v<_Tp&&> = true;
+
+
+template <typename _Tp>
+ inline constexpr bool is_member_object_pointer_v =
+ __is_member_object_pointer(_Tp);
+
+
+
+
+
+
+
+template <typename _Tp>
+ inline constexpr bool is_member_function_pointer_v =
+ __is_member_function_pointer(_Tp);
+
+
+
+
+
+
+template <typename _Tp>
+ inline constexpr bool is_enum_v = __is_enum(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_union_v = __is_union(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_class_v = __is_class(_Tp);
+
+
+
+template <typename _Tp>
+ inline constexpr bool is_reference_v = __is_reference(_Tp);
+# 3323 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+template <typename _Tp>
+ inline constexpr bool is_arithmetic_v = is_arithmetic<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_fundamental_v = is_fundamental<_Tp>::value;
+
+
+template <typename _Tp>
+ inline constexpr bool is_object_v = __is_object(_Tp);
+
+
+
+
+
+template <typename _Tp>
+ inline constexpr bool is_scalar_v = is_scalar<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_compound_v = !is_fundamental_v<_Tp>;
+
+
+template <typename _Tp>
+ inline constexpr bool is_member_pointer_v = __is_member_pointer(_Tp);
+
+
+
+
+
+template <typename _Tp>
+ inline constexpr bool is_const_v = false;
+template <typename _Tp>
+ inline constexpr bool is_const_v<const _Tp> = true;
+
+
+template <typename _Tp>
+ inline constexpr bool is_function_v = __is_function(_Tp);
+# 3366 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+template <typename _Tp>
+ inline constexpr bool is_volatile_v = false;
+template <typename _Tp>
+ inline constexpr bool is_volatile_v<volatile _Tp> = true;
+
+template <typename _Tp>
+ inline constexpr bool is_trivial_v = __is_trivial(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_standard_layout_v = __is_standard_layout(_Tp);
+template <typename _Tp>
+ __attribute__ ((__deprecated__ ("use '" "is_standard_layout_v && is_trivial_v" "' instead")))
+ inline constexpr bool is_pod_v = __is_pod(_Tp);
+template <typename _Tp>
+ [[__deprecated__]]
+ inline constexpr bool is_literal_type_v = __is_literal_type(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_empty_v = __is_empty(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_polymorphic_v = __is_polymorphic(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_abstract_v = __is_abstract(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_final_v = __is_final(_Tp);
+
+template <typename _Tp>
+ inline constexpr bool is_signed_v = is_signed<_Tp>::value;
+template <typename _Tp>
+ inline constexpr bool is_unsigned_v = is_unsigned<_Tp>::value;
+
+template <typename _Tp, typename... _Args>
+ inline constexpr bool is_constructible_v = __is_constructible(_Tp, _Args...);
+template <typename _Tp>
+ inline constexpr bool is_default_constructible_v = __is_constructible(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_copy_constructible_v
+ = __is_constructible(_Tp, __add_lval_ref_t<const _Tp>);
+template <typename _Tp>
+ inline constexpr bool is_move_constructible_v
+ = __is_constructible(_Tp, __add_rval_ref_t<_Tp>);
+
+template <typename _Tp, typename _Up>
+ inline constexpr bool is_assignable_v = __is_assignable(_Tp, _Up);
+template <typename _Tp>
+ inline constexpr bool is_copy_assignable_v
+ = __is_assignable(__add_lval_ref_t<_Tp>, __add_lval_ref_t<const _Tp>);
+template <typename _Tp>
+ inline constexpr bool is_move_assignable_v
+ = __is_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);
+
+template <typename _Tp>
+ inline constexpr bool is_destructible_v = is_destructible<_Tp>::value;
+
+template <typename _Tp, typename... _Args>
+ inline constexpr bool is_trivially_constructible_v
+ = __is_trivially_constructible(_Tp, _Args...);
+template <typename _Tp>
+ inline constexpr bool is_trivially_default_constructible_v
+ = __is_trivially_constructible(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_trivially_copy_constructible_v
+ = __is_trivially_constructible(_Tp, __add_lval_ref_t<const _Tp>);
+template <typename _Tp>
+ inline constexpr bool is_trivially_move_constructible_v
+ = __is_trivially_constructible(_Tp, __add_rval_ref_t<_Tp>);
+
+template <typename _Tp, typename _Up>
+ inline constexpr bool is_trivially_assignable_v
+ = __is_trivially_assignable(_Tp, _Up);
+template <typename _Tp>
+ inline constexpr bool is_trivially_copy_assignable_v
+ = __is_trivially_assignable(__add_lval_ref_t<_Tp>,
+ __add_lval_ref_t<const _Tp>);
+template <typename _Tp>
+ inline constexpr bool is_trivially_move_assignable_v
+ = __is_trivially_assignable(__add_lval_ref_t<_Tp>,
+ __add_rval_ref_t<_Tp>);
+
+
+template <typename _Tp>
+ inline constexpr bool is_trivially_destructible_v = false;
+
+template <typename _Tp>
+ requires (!is_reference_v<_Tp>) && requires (_Tp& __t) { __t.~_Tp(); }
+ inline constexpr bool is_trivially_destructible_v<_Tp>
+ = __has_trivial_destructor(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_trivially_destructible_v<_Tp&> = true;
+template <typename _Tp>
+ inline constexpr bool is_trivially_destructible_v<_Tp&&> = true;
+template <typename _Tp, size_t _Nm>
+ inline constexpr bool is_trivially_destructible_v<_Tp[_Nm]>
+ = is_trivially_destructible_v<_Tp>;
+
+
+
+
+
+
+template <typename _Tp, typename... _Args>
+ inline constexpr bool is_nothrow_constructible_v
+ = __is_nothrow_constructible(_Tp, _Args...);
+template <typename _Tp>
+ inline constexpr bool is_nothrow_default_constructible_v
+ = __is_nothrow_constructible(_Tp);
+template <typename _Tp>
+ inline constexpr bool is_nothrow_copy_constructible_v
+ = __is_nothrow_constructible(_Tp, __add_lval_ref_t<const _Tp>);
+template <typename _Tp>
+ inline constexpr bool is_nothrow_move_constructible_v
+ = __is_nothrow_constructible(_Tp, __add_rval_ref_t<_Tp>);
+
+template <typename _Tp, typename _Up>
+ inline constexpr bool is_nothrow_assignable_v
+ = __is_nothrow_assignable(_Tp, _Up);
+template <typename _Tp>
+ inline constexpr bool is_nothrow_copy_assignable_v
+ = __is_nothrow_assignable(__add_lval_ref_t<_Tp>,
+ __add_lval_ref_t<const _Tp>);
+template <typename _Tp>
+ inline constexpr bool is_nothrow_move_assignable_v
+ = __is_nothrow_assignable(__add_lval_ref_t<_Tp>, __add_rval_ref_t<_Tp>);
+
+template <typename _Tp>
+ inline constexpr bool is_nothrow_destructible_v =
+ is_nothrow_destructible<_Tp>::value;
+
+template <typename _Tp>
+ inline constexpr bool has_virtual_destructor_v
+ = __has_virtual_destructor(_Tp);
+
+template <typename _Tp>
+ inline constexpr size_t alignment_of_v = alignment_of<_Tp>::value;
+
+template <typename _Tp>
+ inline constexpr size_t rank_v = 0;
+template <typename _Tp, size_t _Size>
+ inline constexpr size_t rank_v<_Tp[_Size]> = 1 + rank_v<_Tp>;
+template <typename _Tp>
+ inline constexpr size_t rank_v<_Tp[]> = 1 + rank_v<_Tp>;
+
+template <typename _Tp, unsigned _Idx = 0>
+ inline constexpr size_t extent_v = 0;
+template <typename _Tp, size_t _Size>
+ inline constexpr size_t extent_v<_Tp[_Size], 0> = _Size;
+template <typename _Tp, unsigned _Idx, size_t _Size>
+ inline constexpr size_t extent_v<_Tp[_Size], _Idx> = extent_v<_Tp, _Idx - 1>;
+template <typename _Tp>
+ inline constexpr size_t extent_v<_Tp[], 0> = 0;
+template <typename _Tp, unsigned _Idx>
+ inline constexpr size_t extent_v<_Tp[], _Idx> = extent_v<_Tp, _Idx - 1>;
+
+
+template <typename _Tp, typename _Up>
+ inline constexpr bool is_same_v = __is_same(_Tp, _Up);
+
+
+
+
+
+
+template <typename _Base, typename _Derived>
+ inline constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
+
+template <typename _From, typename _To>
+ inline constexpr bool is_convertible_v = __is_convertible(_From, _To);
+
+
+
+
+template<typename _Fn, typename... _Args>
+ inline constexpr bool is_invocable_v = is_invocable<_Fn, _Args...>::value;
+template<typename _Fn, typename... _Args>
+ inline constexpr bool is_nothrow_invocable_v
+ = is_nothrow_invocable<_Fn, _Args...>::value;
+template<typename _Ret, typename _Fn, typename... _Args>
+ inline constexpr bool is_invocable_r_v
+ = is_invocable_r<_Ret, _Fn, _Args...>::value;
+template<typename _Ret, typename _Fn, typename... _Args>
+ inline constexpr bool is_nothrow_invocable_r_v
+ = is_nothrow_invocable_r<_Ret, _Fn, _Args...>::value;
+
+
+
+
+
+
+ template<typename _Tp>
+ struct has_unique_object_representations
+ : bool_constant<__has_unique_object_representations(
+ remove_cv_t<remove_all_extents_t<_Tp>>
+ )>
+ {
+ static_assert(std::__is_complete_or_unbounded(__type_identity<_Tp>{}),
+ "template argument must be a complete class or an unbounded array");
+ };
+
+
+
+ template<typename _Tp>
+ inline constexpr bool has_unique_object_representations_v
+ = has_unique_object_representations<_Tp>::value;
+
+
+
+
+
+
+ template<typename _Tp>
+ struct is_aggregate
+ : bool_constant<__is_aggregate(remove_cv_t<_Tp>)>
+ { };
+
+
+
+
+
+
+ template<typename _Tp>
+ inline constexpr bool is_aggregate_v = __is_aggregate(remove_cv_t<_Tp>);
+# 3596 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct remove_cvref
+ { using type = __remove_cvref(_Tp); };
+# 3613 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ using remove_cvref_t = typename remove_cvref<_Tp>::type;
+# 3623 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct type_identity { using type = _Tp; };
+
+ template<typename _Tp>
+ using type_identity_t = typename type_identity<_Tp>::type;
+# 3636 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ struct unwrap_reference { using type = _Tp; };
+
+ template<typename _Tp>
+ struct unwrap_reference<reference_wrapper<_Tp>> { using type = _Tp&; };
+
+ template<typename _Tp>
+ using unwrap_reference_t = typename unwrap_reference<_Tp>::type;
+
+
+
+
+
+
+ template<typename _Tp>
+ struct unwrap_ref_decay { using type = unwrap_reference_t<decay_t<_Tp>>; };
+
+ template<typename _Tp>
+ using unwrap_ref_decay_t = typename unwrap_ref_decay<_Tp>::type;
+# 3663 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ inline constexpr bool is_bounded_array_v = __is_bounded_array(_Tp);
+# 3676 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Tp>
+ inline constexpr bool is_unbounded_array_v = false;
+
+ template<typename _Tp>
+ inline constexpr bool is_unbounded_array_v<_Tp[]> = true;
+
+
+
+ template<typename _Tp>
+ struct is_bounded_array
+ : public bool_constant<is_bounded_array_v<_Tp>>
+ { };
+
+
+
+ template<typename _Tp>
+ struct is_unbounded_array
+ : public bool_constant<is_unbounded_array_v<_Tp>>
+ { };
+
+
+
+
+
+ template<typename _Tp, typename _Up>
+ struct is_layout_compatible
+ : bool_constant<__is_layout_compatible(_Tp, _Up)>
+ { };
+
+
+
+ template<typename _Tp, typename _Up>
+ constexpr bool is_layout_compatible_v
+ = __is_layout_compatible(_Tp, _Up);
+# 3728 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ template<typename _Base, typename _Derived>
+ struct is_pointer_interconvertible_base_of
+ : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)>
+ { };
+
+
+
+ template<typename _Base, typename _Derived>
+ constexpr bool is_pointer_interconvertible_base_of_v
+ = __is_pointer_interconvertible_base_of(_Base, _Derived);
+# 3831 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/type_traits" 3
+ constexpr inline bool
+ is_constant_evaluated() noexcept
+ {
+
+
+
+ return __builtin_is_constant_evaluated();
+
+ }
+
+
+
+
+ template<typename _From, typename _To>
+ using __copy_cv = typename __match_cv_qualifiers<_From, _To>::__type;
+
+ template<typename _Xp, typename _Yp>
+ using __cond_res
+ = decltype(false ? declval<_Xp(&)()>()() : declval<_Yp(&)()>()());
+
+ template<typename _Ap, typename _Bp, typename = void>
+ struct __common_ref_impl
+ { };
+
+
+ template<typename _Ap, typename _Bp>
+ using __common_ref = typename __common_ref_impl<_Ap, _Bp>::type;
+
+
+ template<typename _Xp, typename _Yp>
+ using __condres_cvref
+ = __cond_res<__copy_cv<_Xp, _Yp>&, __copy_cv<_Yp, _Xp>&>;
+
+
+ template<typename _Xp, typename _Yp>
+ struct __common_ref_impl<_Xp&, _Yp&, __void_t<__condres_cvref<_Xp, _Yp>>>
+ : enable_if<is_reference_v<__condres_cvref<_Xp, _Yp>>,
+ __condres_cvref<_Xp, _Yp>>
+ { };
+
+
+ template<typename _Xp, typename _Yp>
+ using __common_ref_C = remove_reference_t<__common_ref<_Xp&, _Yp&>>&&;
+
+
+ template<typename _Xp, typename _Yp>
+ struct __common_ref_impl<_Xp&&, _Yp&&,
+ _Require<is_convertible<_Xp&&, __common_ref_C<_Xp, _Yp>>,
+ is_convertible<_Yp&&, __common_ref_C<_Xp, _Yp>>>>
+ { using type = __common_ref_C<_Xp, _Yp>; };
+
+
+ template<typename _Xp, typename _Yp>
+ using __common_ref_D = __common_ref<const _Xp&, _Yp&>;
+
+
+ template<typename _Xp, typename _Yp>
+ struct __common_ref_impl<_Xp&&, _Yp&,
+ _Require<is_convertible<_Xp&&, __common_ref_D<_Xp, _Yp>>>>
+ { using type = __common_ref_D<_Xp, _Yp>; };
+
+
+ template<typename _Xp, typename _Yp>
+ struct __common_ref_impl<_Xp&, _Yp&&>
+ : __common_ref_impl<_Yp&&, _Xp&>
+ { };
+
+
+ template<typename _Tp, typename _Up,
+ template<typename> class _TQual, template<typename> class _UQual>
+ struct basic_common_reference
+ { };
+
+
+ template<typename _Tp>
+ struct __xref
+ { template<typename _Up> using __type = __copy_cv<_Tp, _Up>; };
+
+ template<typename _Tp>
+ struct __xref<_Tp&>
+ { template<typename _Up> using __type = __copy_cv<_Tp, _Up>&; };
+
+ template<typename _Tp>
+ struct __xref<_Tp&&>
+ { template<typename _Up> using __type = __copy_cv<_Tp, _Up>&&; };
+
+ template<typename _Tp1, typename _Tp2>
+ using __basic_common_ref
+ = typename basic_common_reference<remove_cvref_t<_Tp1>,
+ remove_cvref_t<_Tp2>,
+ __xref<_Tp1>::template __type,
+ __xref<_Tp2>::template __type>::type;
+
+
+ template<typename... _Tp>
+ struct common_reference;
+
+ template<typename... _Tp>
+ using common_reference_t = typename common_reference<_Tp...>::type;
+
+
+ template<>
+ struct common_reference<>
+ { };
+
+
+ template<typename _Tp0>
+ struct common_reference<_Tp0>
+ { using type = _Tp0; };
+
+
+ template<typename _Tp1, typename _Tp2, int _Bullet = 1, typename = void>
+ struct __common_reference_impl
+ : __common_reference_impl<_Tp1, _Tp2, _Bullet + 1>
+ { };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct common_reference<_Tp1, _Tp2>
+ : __common_reference_impl<_Tp1, _Tp2>
+ { };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1&, _Tp2&, 1,
+ void_t<__common_ref<_Tp1&, _Tp2&>>>
+ { using type = __common_ref<_Tp1&, _Tp2&>; };
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1&&, _Tp2&&, 1,
+ void_t<__common_ref<_Tp1&&, _Tp2&&>>>
+ { using type = __common_ref<_Tp1&&, _Tp2&&>; };
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1&, _Tp2&&, 1,
+ void_t<__common_ref<_Tp1&, _Tp2&&>>>
+ { using type = __common_ref<_Tp1&, _Tp2&&>; };
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1&&, _Tp2&, 1,
+ void_t<__common_ref<_Tp1&&, _Tp2&>>>
+ { using type = __common_ref<_Tp1&&, _Tp2&>; };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1, _Tp2, 2,
+ void_t<__basic_common_ref<_Tp1, _Tp2>>>
+ { using type = __basic_common_ref<_Tp1, _Tp2>; };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1, _Tp2, 3,
+ void_t<__cond_res<_Tp1, _Tp2>>>
+ { using type = __cond_res<_Tp1, _Tp2>; };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1, _Tp2, 4,
+ void_t<common_type_t<_Tp1, _Tp2>>>
+ { using type = common_type_t<_Tp1, _Tp2>; };
+
+
+ template<typename _Tp1, typename _Tp2>
+ struct __common_reference_impl<_Tp1, _Tp2, 5, void>
+ { };
+
+
+ template<typename _Tp1, typename _Tp2, typename... _Rest>
+ struct common_reference<_Tp1, _Tp2, _Rest...>
+ : __common_type_fold<common_reference<_Tp1, _Tp2>,
+ __common_type_pack<_Rest...>>
+ { };
+
+
+ template<typename _Tp1, typename _Tp2, typename... _Rest>
+ struct __common_type_fold<common_reference<_Tp1, _Tp2>,
+ __common_type_pack<_Rest...>,
+ void_t<common_reference_t<_Tp1, _Tp2>>>
+ : public common_reference<common_reference_t<_Tp1, _Tp2>, _Rest...>
+ { };
+
+
+
+
+
+
+
+}
+# 47 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/concepts" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+ namespace __detail
+ {
+ template<typename _Tp, typename _Up>
+ concept __same_as = std::is_same_v<_Tp, _Up>;
+ }
+
+
+ template<typename _Tp, typename _Up>
+ concept same_as
+ = __detail::__same_as<_Tp, _Up> && __detail::__same_as<_Up, _Tp>;
+
+ namespace __detail
+ {
+ template<typename _Tp, typename _Up>
+ concept __different_from
+ = !same_as<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
+ }
+
+
+ template<typename _Derived, typename _Base>
+ concept derived_from = __is_base_of(_Base, _Derived)
+ && is_convertible_v<const volatile _Derived*, const volatile _Base*>;
+
+
+ template<typename _From, typename _To>
+ concept convertible_to = is_convertible_v<_From, _To>
+ && requires { static_cast<_To>(std::declval<_From>()); };
+
+
+ template<typename _Tp, typename _Up>
+ concept common_reference_with
+ = same_as<common_reference_t<_Tp, _Up>, common_reference_t<_Up, _Tp>>
+ && convertible_to<_Tp, common_reference_t<_Tp, _Up>>
+ && convertible_to<_Up, common_reference_t<_Tp, _Up>>;
+
+
+ template<typename _Tp, typename _Up>
+ concept common_with
+ = same_as<common_type_t<_Tp, _Up>, common_type_t<_Up, _Tp>>
+ && requires {
+ static_cast<common_type_t<_Tp, _Up>>(std::declval<_Tp>());
+ static_cast<common_type_t<_Tp, _Up>>(std::declval<_Up>());
+ }
+ && common_reference_with<add_lvalue_reference_t<const _Tp>,
+ add_lvalue_reference_t<const _Up>>
+ && common_reference_with<add_lvalue_reference_t<common_type_t<_Tp, _Up>>,
+ common_reference_t<
+ add_lvalue_reference_t<const _Tp>,
+ add_lvalue_reference_t<const _Up>>>;
+
+
+
+ template<typename _Tp>
+ concept integral = is_integral_v<_Tp>;
+
+ template<typename _Tp>
+ concept signed_integral = integral<_Tp> && is_signed_v<_Tp>;
+
+ template<typename _Tp>
+ concept unsigned_integral = integral<_Tp> && !signed_integral<_Tp>;
+
+ template<typename _Tp>
+ concept floating_point = is_floating_point_v<_Tp>;
+
+ namespace __detail
+ {
+ template<typename _Tp>
+ using __cref = const remove_reference_t<_Tp>&;
+
+ template<typename _Tp>
+ concept __class_or_enum
+ = is_class_v<_Tp> || is_union_v<_Tp> || is_enum_v<_Tp>;
+
+ template<typename _Tp>
+ constexpr bool __destructible_impl = false;
+ template<typename _Tp>
+ requires requires(_Tp& __t) { { __t.~_Tp() } noexcept; }
+ constexpr bool __destructible_impl<_Tp> = true;
+
+ template<typename _Tp>
+ constexpr bool __destructible = __destructible_impl<_Tp>;
+ template<typename _Tp>
+ constexpr bool __destructible<_Tp&> = true;
+ template<typename _Tp>
+ constexpr bool __destructible<_Tp&&> = true;
+ template<typename _Tp, size_t _Nm>
+ constexpr bool __destructible<_Tp[_Nm]> = __destructible<_Tp>;
+
+ }
+
+
+ template<typename _Lhs, typename _Rhs>
+ concept assignable_from
+ = is_lvalue_reference_v<_Lhs>
+ && common_reference_with<__detail::__cref<_Lhs>, __detail::__cref<_Rhs>>
+ && requires(_Lhs __lhs, _Rhs&& __rhs) {
+ { __lhs = static_cast<_Rhs&&>(__rhs) } -> same_as<_Lhs>;
+ };
+
+
+ template<typename _Tp>
+ concept destructible = __detail::__destructible<_Tp>;
+
+
+ template<typename _Tp, typename... _Args>
+ concept constructible_from
+ = destructible<_Tp> && is_constructible_v<_Tp, _Args...>;
+
+
+ template<typename _Tp>
+ concept default_initializable = constructible_from<_Tp>
+ && requires
+ {
+ _Tp{};
+ (void) ::new _Tp;
+ };
+
+
+ template<typename _Tp>
+ concept move_constructible
+ = constructible_from<_Tp, _Tp> && convertible_to<_Tp, _Tp>;
+
+
+ template<typename _Tp>
+ concept copy_constructible
+ = move_constructible<_Tp>
+ && constructible_from<_Tp, _Tp&> && convertible_to<_Tp&, _Tp>
+ && constructible_from<_Tp, const _Tp&> && convertible_to<const _Tp&, _Tp>
+ && constructible_from<_Tp, const _Tp> && convertible_to<const _Tp, _Tp>;
+
+
+
+ namespace ranges
+ {
+
+ namespace __swap
+ {
+ template<typename _Tp> void swap(_Tp&, _Tp&) = delete;
+
+ template<typename _Tp, typename _Up>
+ concept __adl_swap
+ = (std::__detail::__class_or_enum<remove_reference_t<_Tp>>
+ || std::__detail::__class_or_enum<remove_reference_t<_Up>>)
+ && requires(_Tp&& __t, _Up&& __u) {
+ swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
+ };
+
+ struct _Swap
+ {
+ private:
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (__adl_swap<_Tp, _Up>)
+ return noexcept(swap(std::declval<_Tp>(), std::declval<_Up>()));
+ else
+ return is_nothrow_move_constructible_v<remove_reference_t<_Tp>>
+ && is_nothrow_move_assignable_v<remove_reference_t<_Tp>>;
+ }
+
+ public:
+ template<typename _Tp, typename _Up>
+ requires __adl_swap<_Tp, _Up>
+ || (same_as<_Tp, _Up> && is_lvalue_reference_v<_Tp>
+ && move_constructible<remove_reference_t<_Tp>>
+ && assignable_from<_Tp, remove_reference_t<_Tp>>)
+ constexpr void
+ operator()(_Tp&& __t, _Up&& __u) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (__adl_swap<_Tp, _Up>)
+ swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
+ else
+ {
+ auto __tmp = static_cast<remove_reference_t<_Tp>&&>(__t);
+ __t = static_cast<remove_reference_t<_Tp>&&>(__u);
+ __u = static_cast<remove_reference_t<_Tp>&&>(__tmp);
+ }
+ }
+
+ template<typename _Tp, typename _Up, size_t _Num>
+ requires requires(const _Swap& __swap, _Tp& __e1, _Up& __e2) {
+ __swap(__e1, __e2);
+ }
+ constexpr void
+ operator()(_Tp (&__e1)[_Num], _Up (&__e2)[_Num]) const
+ noexcept(noexcept(std::declval<const _Swap&>()(*__e1, *__e2)))
+ {
+ for (size_t __n = 0; __n < _Num; ++__n)
+ (*this)(__e1[__n], __e2[__n]);
+ }
+ };
+ }
+
+
+ inline namespace _Cpo {
+ inline constexpr __swap::_Swap swap{};
+ }
+ }
+
+ template<typename _Tp>
+ concept swappable
+ = requires(_Tp& __a, _Tp& __b) { ranges::swap(__a, __b); };
+
+ template<typename _Tp, typename _Up>
+ concept swappable_with = common_reference_with<_Tp, _Up>
+ && requires(_Tp&& __t, _Up&& __u) {
+ ranges::swap(static_cast<_Tp&&>(__t), static_cast<_Tp&&>(__t));
+ ranges::swap(static_cast<_Up&&>(__u), static_cast<_Up&&>(__u));
+ ranges::swap(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u));
+ ranges::swap(static_cast<_Up&&>(__u), static_cast<_Tp&&>(__t));
+ };
+
+
+
+ template<typename _Tp>
+ concept movable = is_object_v<_Tp> && move_constructible<_Tp>
+ && assignable_from<_Tp&, _Tp> && swappable<_Tp>;
+
+ template<typename _Tp>
+ concept copyable = copy_constructible<_Tp> && movable<_Tp>
+ && assignable_from<_Tp&, _Tp&> && assignable_from<_Tp&, const _Tp&>
+ && assignable_from<_Tp&, const _Tp>;
+
+ template<typename _Tp>
+ concept semiregular = copyable<_Tp> && default_initializable<_Tp>;
+
+
+
+
+ namespace __detail
+ {
+ template<typename _Tp>
+ concept __boolean_testable_impl = convertible_to<_Tp, bool>;
+
+ template<typename _Tp>
+ concept __boolean_testable
+ = __boolean_testable_impl<_Tp>
+ && requires(_Tp&& __t)
+ { { !static_cast<_Tp&&>(__t) } -> __boolean_testable_impl; };
+ }
+
+
+
+ namespace __detail
+ {
+ template<typename _Tp, typename _Up>
+ concept __weakly_eq_cmp_with
+ = requires(__detail::__cref<_Tp> __t, __detail::__cref<_Up> __u) {
+ { __t == __u } -> __boolean_testable;
+ { __t != __u } -> __boolean_testable;
+ { __u == __t } -> __boolean_testable;
+ { __u != __t } -> __boolean_testable;
+ };
+ }
+
+ template<typename _Tp>
+ concept equality_comparable = __detail::__weakly_eq_cmp_with<_Tp, _Tp>;
+
+ template<typename _Tp, typename _Up>
+ concept equality_comparable_with
+ = equality_comparable<_Tp> && equality_comparable<_Up>
+ && common_reference_with<__detail::__cref<_Tp>, __detail::__cref<_Up>>
+ && equality_comparable<common_reference_t<__detail::__cref<_Tp>,
+ __detail::__cref<_Up>>>
+ && __detail::__weakly_eq_cmp_with<_Tp, _Up>;
+
+ namespace __detail
+ {
+ template<typename _Tp, typename _Up>
+ concept __partially_ordered_with
+ = requires(const remove_reference_t<_Tp>& __t,
+ const remove_reference_t<_Up>& __u) {
+ { __t < __u } -> __boolean_testable;
+ { __t > __u } -> __boolean_testable;
+ { __t <= __u } -> __boolean_testable;
+ { __t >= __u } -> __boolean_testable;
+ { __u < __t } -> __boolean_testable;
+ { __u > __t } -> __boolean_testable;
+ { __u <= __t } -> __boolean_testable;
+ { __u >= __t } -> __boolean_testable;
+ };
+ }
+
+
+ template<typename _Tp>
+ concept totally_ordered
+ = equality_comparable<_Tp>
+ && __detail::__partially_ordered_with<_Tp, _Tp>;
+
+ template<typename _Tp, typename _Up>
+ concept totally_ordered_with
+ = totally_ordered<_Tp> && totally_ordered<_Up>
+ && equality_comparable_with<_Tp, _Up>
+ && totally_ordered<common_reference_t<__detail::__cref<_Tp>,
+ __detail::__cref<_Up>>>
+ && __detail::__partially_ordered_with<_Tp, _Up>;
+
+ template<typename _Tp>
+ concept regular = semiregular<_Tp> && equality_comparable<_Tp>;
+
+
+
+
+ template<typename _Fn, typename... _Args>
+ concept invocable = is_invocable_v<_Fn, _Args...>;
+
+
+ template<typename _Fn, typename... _Args>
+ concept regular_invocable = invocable<_Fn, _Args...>;
+
+
+ template<typename _Fn, typename... _Args>
+ concept predicate = regular_invocable<_Fn, _Args...>
+ && __detail::__boolean_testable<invoke_result_t<_Fn, _Args...>>;
+
+
+ template<typename _Rel, typename _Tp, typename _Up>
+ concept relation
+ = predicate<_Rel, _Tp, _Tp> && predicate<_Rel, _Up, _Up>
+ && predicate<_Rel, _Tp, _Up> && predicate<_Rel, _Up, _Tp>;
+
+
+ template<typename _Rel, typename _Tp, typename _Up>
+ concept equivalence_relation = relation<_Rel, _Tp, _Up>;
+
+
+ template<typename _Rel, typename _Tp, typename _Up>
+ concept strict_weak_order = relation<_Rel, _Tp, _Up>;
+
+
+}
+# 2 "includes.hpp" 2
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 1 3
+# 59 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 3
+# 68 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_relops.h" 1 3
+# 62 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_relops.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+ namespace rel_ops
+ {
+# 86 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_relops.h" 3
+ template <class _Tp>
+ inline bool
+ operator!=(const _Tp& __x, const _Tp& __y)
+ { return !(__x == __y); }
+# 99 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_relops.h" 3
+ template <class _Tp>
+ inline bool
+ operator>(const _Tp& __x, const _Tp& __y)
+ { return __y < __x; }
+# 112 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_relops.h" 3
+ template <class _Tp>
+ inline bool
+ operator<=(const _Tp& __x, const _Tp& __y)
+ { return !(__y < __x); }
+# 125 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_relops.h" 3
+ template <class _Tp>
+ inline bool
+ operator>=(const _Tp& __x, const _Tp& __y)
+ { return !(__x < __y); }
+ }
+
+
+}
+# 69 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 2 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 1 3
+# 61 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 1 3
+# 40 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+
+
+
+ template<typename _Tp>
+ inline constexpr _Tp*
+ __addressof(_Tp& __r) noexcept
+ { return __builtin_addressof(__r); }
+# 68 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+ template<typename _Tp>
+ [[__nodiscard__]]
+ constexpr _Tp&&
+ forward(typename std::remove_reference<_Tp>::type& __t) noexcept
+ { return static_cast<_Tp&&>(__t); }
+# 81 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+ template<typename _Tp>
+ [[__nodiscard__]]
+ constexpr _Tp&&
+ forward(typename std::remove_reference<_Tp>::type&& __t) noexcept
+ {
+ static_assert(!std::is_lvalue_reference<_Tp>::value,
+ "std::forward must not be used to convert an rvalue to an lvalue");
+ return static_cast<_Tp&&>(__t);
+ }
+# 134 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+ template<typename _Tp>
+ [[__nodiscard__]]
+ constexpr typename std::remove_reference<_Tp>::type&&
+ move(_Tp&& __t) noexcept
+ { return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }
+
+
+ template<typename _Tp>
+ struct __move_if_noexcept_cond
+ : public __and_<__not_<is_nothrow_move_constructible<_Tp>>,
+ is_copy_constructible<_Tp>>::type { };
+# 155 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+ template<typename _Tp>
+ [[__nodiscard__]]
+ constexpr
+ __conditional_t<__move_if_noexcept_cond<_Tp>::value, const _Tp&, _Tp&&>
+ move_if_noexcept(_Tp& __x) noexcept
+ { return std::move(__x); }
+# 172 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+ template<typename _Tp>
+ [[__nodiscard__]]
+ inline constexpr _Tp*
+ addressof(_Tp& __r) noexcept
+ { return std::__addressof(__r); }
+
+
+
+ template<typename _Tp>
+ const _Tp* addressof(const _Tp&&) = delete;
+
+
+ template <typename _Tp, typename _Up = _Tp>
+ constexpr
+ inline _Tp
+ __exchange(_Tp& __obj, _Up&& __new_val)
+ {
+ _Tp __old_val = std::move(__obj);
+ __obj = std::forward<_Up>(__new_val);
+ return __old_val;
+ }
+# 216 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/move.h" 3
+ template<typename _Tp>
+ constexpr
+ inline
+
+ typename enable_if<__and_<__not_<__is_tuple_like<_Tp>>,
+ is_move_constructible<_Tp>,
+ is_move_assignable<_Tp>>::value>::type
+
+
+
+ swap(_Tp& __a, _Tp& __b)
+ noexcept(__and_<is_nothrow_move_constructible<_Tp>, is_nothrow_move_assignable<_Tp>>::value)
+
+ {
+
+
+
+
+ _Tp __tmp = std::move(__a);
+ __a = std::move(__b);
+ __b = std::move(__tmp);
+ }
+
+
+
+
+ template<typename _Tp, size_t _Nm>
+ constexpr
+ inline
+
+ typename enable_if<__is_swappable<_Tp>::value>::type
+
+
+
+ swap(_Tp (&__a)[_Nm], _Tp (&__b)[_Nm])
+ noexcept(__is_nothrow_swappable<_Tp>::value)
+ {
+ for (size_t __n = 0; __n < _Nm; ++__n)
+ swap(__a[__n], __b[__n]);
+ }
+
+
+
+}
+# 62 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 2 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/utility.h" 1 3
+# 37 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/utility.h" 3
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+ template<typename _Tp>
+ struct tuple_size;
+
+
+
+
+
+ template<typename _Tp,
+ typename _Up = typename remove_cv<_Tp>::type,
+ typename = typename enable_if<is_same<_Tp, _Up>::value>::type,
+ size_t = tuple_size<_Tp>::value>
+ using __enable_if_has_tuple_size = _Tp;
+
+ template<typename _Tp>
+ struct tuple_size<const __enable_if_has_tuple_size<_Tp>>
+ : public tuple_size<_Tp> { };
+
+ template<typename _Tp>
+ struct tuple_size<volatile __enable_if_has_tuple_size<_Tp>>
+ : public tuple_size<_Tp> { };
+
+ template<typename _Tp>
+ struct tuple_size<const volatile __enable_if_has_tuple_size<_Tp>>
+ : public tuple_size<_Tp> { };
+
+
+ template<typename _Tp>
+ inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;
+
+
+
+ template<size_t __i, typename _Tp>
+ struct tuple_element;
+
+
+ template<size_t __i, typename _Tp>
+ using __tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+ template<size_t __i, typename _Tp>
+ struct tuple_element<__i, const _Tp>
+ {
+ using type = const __tuple_element_t<__i, _Tp>;
+ };
+
+ template<size_t __i, typename _Tp>
+ struct tuple_element<__i, volatile _Tp>
+ {
+ using type = volatile __tuple_element_t<__i, _Tp>;
+ };
+
+ template<size_t __i, typename _Tp>
+ struct tuple_element<__i, const volatile _Tp>
+ {
+ using type = const volatile __tuple_element_t<__i, _Tp>;
+ };
+
+
+
+
+
+ template<typename _Tp, typename... _Types>
+ constexpr size_t
+ __find_uniq_type_in_pack()
+ {
+ constexpr size_t __sz = sizeof...(_Types);
+ constexpr bool __found[__sz] = { __is_same(_Tp, _Types) ... };
+ size_t __n = __sz;
+ for (size_t __i = 0; __i < __sz; ++__i)
+ {
+ if (__found[__i])
+ {
+ if (__n < __sz)
+ return __sz;
+ __n = __i;
+ }
+ }
+ return __n;
+ }
+# 134 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/utility.h" 3
+ template<size_t __i, typename _Tp>
+ using tuple_element_t = typename tuple_element<__i, _Tp>::type;
+
+
+
+
+ template<size_t... _Indexes> struct _Index_tuple { };
+
+
+ template<size_t _Num>
+ struct _Build_index_tuple
+ {
+
+ template<typename, size_t... _Indices>
+ using _IdxTuple = _Index_tuple<_Indices...>;
+
+
+ using __type = __make_integer_seq<_IdxTuple, size_t, _Num>;
+
+
+
+
+ };
+
+
+
+
+ template<typename _Tp, _Tp... _Idx>
+ struct integer_sequence
+ {
+
+ static_assert(is_integral_v<_Tp>);
+
+ typedef _Tp value_type;
+ static constexpr size_t size() noexcept { return sizeof...(_Idx); }
+ };
+
+
+ template<typename _Tp, _Tp _Num>
+ using make_integer_sequence
+
+ = __make_integer_seq<integer_sequence, _Tp, _Num>;
+
+
+
+
+
+ template<size_t... _Idx>
+ using index_sequence = integer_sequence<size_t, _Idx...>;
+
+
+ template<size_t _Num>
+ using make_index_sequence = make_integer_sequence<size_t, _Num>;
+
+
+ template<typename... _Types>
+ using index_sequence_for = make_index_sequence<sizeof...(_Types)>;
+
+
+
+
+ struct in_place_t {
+ explicit in_place_t() = default;
+ };
+
+ inline constexpr in_place_t in_place{};
+
+ template<typename _Tp> struct in_place_type_t
+ {
+ explicit in_place_type_t() = default;
+ };
+
+ template<typename _Tp>
+ inline constexpr in_place_type_t<_Tp> in_place_type{};
+
+ template<size_t _Idx> struct in_place_index_t
+ {
+ explicit in_place_index_t() = default;
+ };
+
+ template<size_t _Idx>
+ inline constexpr in_place_index_t<_Idx> in_place_index{};
+
+ template<typename>
+ inline constexpr bool __is_in_place_type_v = false;
+
+ template<typename _Tp>
+ inline constexpr bool __is_in_place_type_v<in_place_type_t<_Tp>> = true;
+
+ template<typename _Tp>
+ using __is_in_place_type = bool_constant<__is_in_place_type_v<_Tp>>;
+
+ template<typename>
+ inline constexpr bool __is_in_place_index_v = false;
+
+ template<size_t _Nm>
+ inline constexpr bool __is_in_place_index_v<in_place_index_t<_Nm>> = true;
+
+
+
+
+ template<size_t _Np, typename... _Types>
+ struct _Nth_type
+ { using type = __type_pack_element<_Np, _Types...>; };
+# 276 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/utility.h" 3
+ namespace ranges::__detail
+ {
+ template<typename _Range>
+ inline constexpr bool __is_subrange = false;
+ }
+
+
+
+}
+# 63 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 2 3
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 1 3
+# 34 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 1 3
+# 48 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 3
+# 37 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 2 3
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+ namespace __cmp_cat
+ {
+ using type = signed char;
+
+ enum class _Ord : type { equivalent = 0, less = -1, greater = 1 };
+
+ enum class _Ncmp : type { _Unordered = 2 };
+
+ struct __unspec
+ {
+ consteval __unspec(__unspec*) noexcept { }
+ };
+ }
+
+ class partial_ordering
+ {
+
+ __cmp_cat::type _M_value;
+
+ constexpr explicit
+ partial_ordering(__cmp_cat::_Ord __v) noexcept
+ : _M_value(__cmp_cat::type(__v))
+ { }
+
+ constexpr explicit
+ partial_ordering(__cmp_cat::_Ncmp __v) noexcept
+ : _M_value(__cmp_cat::type(__v))
+ { }
+
+ friend class weak_ordering;
+ friend class strong_ordering;
+
+ public:
+
+ static const partial_ordering less;
+ static const partial_ordering equivalent;
+ static const partial_ordering greater;
+ static const partial_ordering unordered;
+
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(partial_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value == 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(partial_ordering, partial_ordering) noexcept = default;
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator< (partial_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value == -1; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator> (partial_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value == 1; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator<=(partial_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value <= 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator>=(partial_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator< (__cmp_cat::__unspec, partial_ordering __v) noexcept
+ { return __v._M_value == 1; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator> (__cmp_cat::__unspec, partial_ordering __v) noexcept
+ { return __v._M_value == -1; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator<=(__cmp_cat::__unspec, partial_ordering __v) noexcept
+ { return __cmp_cat::type(__v._M_value & 1) == __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator>=(__cmp_cat::__unspec, partial_ordering __v) noexcept
+ { return 0 >= __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr partial_ordering
+ operator<=>(partial_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v; }
+
+ [[nodiscard]]
+ friend constexpr partial_ordering
+ operator<=>(__cmp_cat::__unspec, partial_ordering __v) noexcept
+ {
+ if (__v._M_value & 1)
+ return partial_ordering(__cmp_cat::_Ord(-__v._M_value));
+ else
+ return __v;
+ }
+ };
+
+
+ inline constexpr partial_ordering
+ partial_ordering::less(__cmp_cat::_Ord::less);
+
+ inline constexpr partial_ordering
+ partial_ordering::equivalent(__cmp_cat::_Ord::equivalent);
+
+ inline constexpr partial_ordering
+ partial_ordering::greater(__cmp_cat::_Ord::greater);
+
+ inline constexpr partial_ordering
+ partial_ordering::unordered(__cmp_cat::_Ncmp::_Unordered);
+
+ class weak_ordering
+ {
+ __cmp_cat::type _M_value;
+
+ constexpr explicit
+ weak_ordering(__cmp_cat::_Ord __v) noexcept : _M_value(__cmp_cat::type(__v))
+ { }
+
+ friend class strong_ordering;
+
+ public:
+
+ static const weak_ordering less;
+ static const weak_ordering equivalent;
+ static const weak_ordering greater;
+
+ [[nodiscard]]
+ constexpr operator partial_ordering() const noexcept
+ { return partial_ordering(__cmp_cat::_Ord(_M_value)); }
+
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(weak_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value == 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(weak_ordering, weak_ordering) noexcept = default;
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator< (weak_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value < 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator> (weak_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value > 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator<=(weak_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value <= 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator>=(weak_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value >= 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator< (__cmp_cat::__unspec, weak_ordering __v) noexcept
+ { return 0 < __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator> (__cmp_cat::__unspec, weak_ordering __v) noexcept
+ { return 0 > __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator<=(__cmp_cat::__unspec, weak_ordering __v) noexcept
+ { return 0 <= __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator>=(__cmp_cat::__unspec, weak_ordering __v) noexcept
+ { return 0 >= __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr weak_ordering
+ operator<=>(weak_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v; }
+
+ [[nodiscard]]
+ friend constexpr weak_ordering
+ operator<=>(__cmp_cat::__unspec, weak_ordering __v) noexcept
+ { return weak_ordering(__cmp_cat::_Ord(-__v._M_value)); }
+ };
+
+
+ inline constexpr weak_ordering
+ weak_ordering::less(__cmp_cat::_Ord::less);
+
+ inline constexpr weak_ordering
+ weak_ordering::equivalent(__cmp_cat::_Ord::equivalent);
+
+ inline constexpr weak_ordering
+ weak_ordering::greater(__cmp_cat::_Ord::greater);
+
+ class strong_ordering
+ {
+ __cmp_cat::type _M_value;
+
+ constexpr explicit
+ strong_ordering(__cmp_cat::_Ord __v) noexcept
+ : _M_value(__cmp_cat::type(__v))
+ { }
+
+ public:
+
+ static const strong_ordering less;
+ static const strong_ordering equal;
+ static const strong_ordering equivalent;
+ static const strong_ordering greater;
+
+ [[nodiscard]]
+ constexpr operator partial_ordering() const noexcept
+ { return partial_ordering(__cmp_cat::_Ord(_M_value)); }
+
+ [[nodiscard]]
+ constexpr operator weak_ordering() const noexcept
+ { return weak_ordering(__cmp_cat::_Ord(_M_value)); }
+
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(strong_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value == 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator==(strong_ordering, strong_ordering) noexcept = default;
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator< (strong_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value < 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator> (strong_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value > 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator<=(strong_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value <= 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator>=(strong_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v._M_value >= 0; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator< (__cmp_cat::__unspec, strong_ordering __v) noexcept
+ { return 0 < __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator> (__cmp_cat::__unspec, strong_ordering __v) noexcept
+ { return 0 > __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator<=(__cmp_cat::__unspec, strong_ordering __v) noexcept
+ { return 0 <= __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr bool
+ operator>=(__cmp_cat::__unspec, strong_ordering __v) noexcept
+ { return 0 >= __v._M_value; }
+
+ [[nodiscard]]
+ friend constexpr strong_ordering
+ operator<=>(strong_ordering __v, __cmp_cat::__unspec) noexcept
+ { return __v; }
+
+ [[nodiscard]]
+ friend constexpr strong_ordering
+ operator<=>(__cmp_cat::__unspec, strong_ordering __v) noexcept
+ { return strong_ordering(__cmp_cat::_Ord(-__v._M_value)); }
+ };
+
+
+ inline constexpr strong_ordering
+ strong_ordering::less(__cmp_cat::_Ord::less);
+
+ inline constexpr strong_ordering
+ strong_ordering::equal(__cmp_cat::_Ord::equivalent);
+
+ inline constexpr strong_ordering
+ strong_ordering::equivalent(__cmp_cat::_Ord::equivalent);
+
+ inline constexpr strong_ordering
+ strong_ordering::greater(__cmp_cat::_Ord::greater);
+
+
+
+ [[nodiscard]]
+ constexpr bool
+ is_eq(partial_ordering __cmp) noexcept
+ { return __cmp == 0; }
+
+ [[nodiscard]]
+ constexpr bool
+ is_neq(partial_ordering __cmp) noexcept
+ { return __cmp != 0; }
+
+ [[nodiscard]]
+ constexpr bool
+ is_lt (partial_ordering __cmp) noexcept
+ { return __cmp < 0; }
+
+ [[nodiscard]]
+ constexpr bool
+ is_lteq(partial_ordering __cmp) noexcept
+ { return __cmp <= 0; }
+
+ [[nodiscard]]
+ constexpr bool
+ is_gt (partial_ordering __cmp) noexcept
+ { return __cmp > 0; }
+
+ [[nodiscard]]
+ constexpr bool
+ is_gteq(partial_ordering __cmp) noexcept
+ { return __cmp >= 0; }
+
+ namespace __detail
+ {
+ template<typename _Tp>
+ inline constexpr unsigned __cmp_cat_id = 1;
+ template<>
+ inline constexpr unsigned __cmp_cat_id<partial_ordering> = 2;
+ template<>
+ inline constexpr unsigned __cmp_cat_id<weak_ordering> = 4;
+ template<>
+ inline constexpr unsigned __cmp_cat_id<strong_ordering> = 8;
+
+ template<typename... _Ts>
+ constexpr auto __common_cmp_cat()
+ {
+ constexpr unsigned __cats = (__cmp_cat_id<_Ts> | ...);
+
+ if constexpr (__cats & 1)
+ return;
+
+
+ else if constexpr (bool(__cats & __cmp_cat_id<partial_ordering>))
+ return partial_ordering::equivalent;
+
+
+ else if constexpr (bool(__cats & __cmp_cat_id<weak_ordering>))
+ return weak_ordering::equivalent;
+
+ else
+ return strong_ordering::equivalent;
+ }
+ }
+
+
+ template<typename... _Ts>
+ struct common_comparison_category
+ {
+ using type = decltype(__detail::__common_cmp_cat<_Ts...>());
+ };
+
+
+
+ template<typename _Tp>
+ struct common_comparison_category<_Tp>
+ { using type = void; };
+
+ template<>
+ struct common_comparison_category<partial_ordering>
+ { using type = partial_ordering; };
+
+ template<>
+ struct common_comparison_category<weak_ordering>
+ { using type = weak_ordering; };
+
+ template<>
+ struct common_comparison_category<strong_ordering>
+ { using type = strong_ordering; };
+
+ template<>
+ struct common_comparison_category<>
+ { using type = strong_ordering; };
+
+ template<typename... _Ts>
+ using common_comparison_category_t
+ = typename common_comparison_category<_Ts...>::type;
+
+
+
+ namespace __detail
+ {
+ template<typename _Tp, typename _Cat>
+ concept __compares_as
+ = same_as<common_comparison_category_t<_Tp, _Cat>, _Cat>;
+ }
+
+
+ template<typename _Tp, typename _Cat = partial_ordering>
+ concept three_way_comparable
+ = __detail::__weakly_eq_cmp_with<_Tp, _Tp>
+ && __detail::__partially_ordered_with<_Tp, _Tp>
+ && requires(const remove_reference_t<_Tp>& __a,
+ const remove_reference_t<_Tp>& __b)
+ {
+ { __a <=> __b } -> __detail::__compares_as<_Cat>;
+ };
+
+ template<typename _Tp, typename _Up, typename _Cat = partial_ordering>
+ concept three_way_comparable_with
+ = three_way_comparable<_Tp, _Cat>
+ && three_way_comparable<_Up, _Cat>
+ && common_reference_with<const remove_reference_t<_Tp>&,
+ const remove_reference_t<_Up>&>
+ && three_way_comparable<
+ common_reference_t<const remove_reference_t<_Tp>&,
+ const remove_reference_t<_Up>&>, _Cat>
+ && __detail::__weakly_eq_cmp_with<_Tp, _Up>
+ && __detail::__partially_ordered_with<_Tp, _Up>
+ && requires(const remove_reference_t<_Tp>& __t,
+ const remove_reference_t<_Up>& __u)
+ {
+ { __t <=> __u } -> __detail::__compares_as<_Cat>;
+ { __u <=> __t } -> __detail::__compares_as<_Cat>;
+ };
+
+ namespace __detail
+ {
+ template<typename _Tp, typename _Up>
+ using __cmp3way_res_t
+ = decltype(std::declval<_Tp>() <=> std::declval<_Up>());
+
+
+
+
+
+
+ template<typename _Tp, typename _Up>
+ struct __cmp3way_res_impl
+ { };
+
+ template<typename _Tp, typename _Up>
+ requires requires { typename __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>; }
+ struct __cmp3way_res_impl<_Tp, _Up>
+ {
+ using type = __cmp3way_res_t<__cref<_Tp>, __cref<_Up>>;
+ };
+ }
+
+
+ template<typename _Tp, typename _Up = _Tp>
+ struct compare_three_way_result
+ : __detail::__cmp3way_res_impl<_Tp, _Up>
+ { };
+
+
+ template<typename _Tp, typename _Up = _Tp>
+ using compare_three_way_result_t
+ = typename __detail::__cmp3way_res_impl<_Tp, _Up>::type;
+
+ namespace __detail
+ {
+
+
+
+
+ template<typename _Tp, typename _Up>
+ concept __3way_builtin_ptr_cmp
+ = requires(_Tp&& __t, _Up&& __u)
+ { static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u); }
+ && convertible_to<_Tp, const volatile void*>
+ && convertible_to<_Up, const volatile void*>
+ && ! requires(_Tp&& __t, _Up&& __u)
+ { operator<=>(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)); }
+ && ! requires(_Tp&& __t, _Up&& __u)
+ { static_cast<_Tp&&>(__t).operator<=>(static_cast<_Up&&>(__u)); };
+ }
+
+
+
+
+
+ struct compare_three_way
+ {
+ template<typename _Tp, typename _Up>
+ requires three_way_comparable_with<_Tp, _Up>
+ constexpr auto
+ operator() [[nodiscard]] (_Tp&& __t, _Up&& __u) const
+ noexcept(noexcept(std::declval<_Tp>() <=> std::declval<_Up>()))
+ {
+ if constexpr (__detail::__3way_builtin_ptr_cmp<_Tp, _Up>)
+ {
+ auto __pt = static_cast<const volatile void*>(__t);
+ auto __pu = static_cast<const volatile void*>(__u);
+ if (std::__is_constant_evaluated())
+ return __pt <=> __pu;
+ auto __it = reinterpret_cast<long unsigned int>(__pt);
+ auto __iu = reinterpret_cast<long unsigned int>(__pu);
+ return __it <=> __iu;
+ }
+ else
+ return static_cast<_Tp&&>(__t) <=> static_cast<_Up&&>(__u);
+ }
+
+ using is_transparent = void;
+ };
+
+
+
+ namespace __compare
+ {
+ template<floating_point _Tp>
+ constexpr weak_ordering
+ __fp_weak_ordering(_Tp __e, _Tp __f)
+ {
+
+
+ auto __cat = [](_Tp __fp) -> int {
+ const int __sign = __builtin_signbit(__fp) ? -1 : 1;
+ if (__builtin_isnormal(__fp))
+ return (__fp == 0 ? 1 : 3) * __sign;
+ if (__builtin_isnan(__fp))
+ return 5 * __sign;
+ if (int __inf = __builtin_isinf_sign(__fp))
+ return 4 * __inf;
+ return 2 * __sign;
+ };
+
+ auto __po = __e <=> __f;
+ if (is_lt(__po))
+ return weak_ordering::less;
+ else if (is_gt(__po))
+ return weak_ordering::greater;
+ else if (__po == partial_ordering::equivalent)
+ return weak_ordering::equivalent;
+ else
+ {
+
+ auto __isnan_sign = [](_Tp __fp) -> int {
+ return __builtin_isnan(__fp)
+ ? __builtin_signbit(__fp) ? -1 : 1
+ : 0;
+ };
+ auto __ord = __isnan_sign(__e) <=> __isnan_sign(__f);
+ if (is_eq(__ord))
+ return weak_ordering::equivalent;
+ else if (is_lt(__ord))
+ return weak_ordering::less;
+ else
+ return weak_ordering::greater;
+ }
+ }
+
+ void strong_order() = delete;
+
+ template<typename _Tp, typename _Up>
+ concept __adl_strong = requires(_Tp&& __t, _Up&& __u)
+ {
+ strong_ordering(strong_order(static_cast<_Tp&&>(__t),
+ static_cast<_Up&&>(__u)));
+ };
+
+ void weak_order() = delete;
+
+ template<typename _Tp, typename _Up>
+ concept __adl_weak = requires(_Tp&& __t, _Up&& __u)
+ {
+ weak_ordering(weak_order(static_cast<_Tp&&>(__t),
+ static_cast<_Up&&>(__u)));
+ };
+
+ void partial_order() = delete;
+
+ template<typename _Tp, typename _Up>
+ concept __adl_partial = requires(_Tp&& __t, _Up&& __u)
+ {
+ partial_ordering(partial_order(static_cast<_Tp&&>(__t),
+ static_cast<_Up&&>(__u)));
+ };
+
+ template<typename _Ord, typename _Tp, typename _Up>
+ concept __cmp3way = requires(_Tp&& __t, _Up&& __u, compare_three_way __c)
+ {
+ _Ord(__c(static_cast<_Tp&&>(__t), static_cast<_Up&&>(__u)));
+ };
+
+ template<typename _Tp, typename _Up>
+ concept __strongly_ordered
+ = __adl_strong<_Tp, _Up>
+ || floating_point<remove_reference_t<_Tp>>
+ || __cmp3way<strong_ordering, _Tp, _Up>;
+
+ template<typename _Tp, typename _Up>
+ concept __decayed_same_as = same_as<decay_t<_Tp>, decay_t<_Up>>;
+
+ class _Strong_order
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (floating_point<decay_t<_Tp>>)
+ return true;
+ else if constexpr (__adl_strong<_Tp, _Up>)
+ return noexcept(strong_ordering(strong_order(std::declval<_Tp>(),
+ std::declval<_Up>())));
+ else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
+ return noexcept(compare_three_way()(std::declval<_Tp>(),
+ std::declval<_Up>()));
+ }
+
+ friend class _Weak_order;
+ friend class _Strong_fallback;
+
+
+ enum class _Fp_fmt
+ {
+ _Binary16, _Binary32, _Binary64, _Binary128,
+ _X86_80bit,
+ _M68k_80bit,
+ _Dbldbl,
+ _Bfloat16,
+ };
+# 699 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+ template<typename _Tp>
+ static consteval _Fp_fmt
+ _S_fp_fmt() noexcept
+ {
+
+ using enum _Fp_fmt;
+# 719 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+ if constexpr (__is_same(_Tp, long double))
+ return (-16381) == -16381 ? _X86_80bit : _M68k_80bit;
+# 731 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+ constexpr int __width = sizeof(_Tp) * 8;
+
+ if constexpr (__width == 16)
+ return _Binary16;
+ else if constexpr (__width == 32)
+ return _Binary32;
+ else if constexpr (__width == 64)
+ return _Binary64;
+ else if constexpr (__width == 128)
+ return _Binary128;
+ }
+
+
+ using int64_t = long int;
+ using int32_t = int;
+ using int16_t = short;
+ using uint64_t = long unsigned int;
+ using uint16_t = unsigned short;
+
+
+ template<typename _Tp>
+ struct _Int
+ {
+
+ uint64_t _M_lo;
+ _Tp _M_hi;
+
+
+
+
+
+ constexpr explicit
+ _Int(_Tp __hi, uint64_t __lo) noexcept : _M_hi(__hi)
+ { _M_lo = __lo; }
+
+ constexpr explicit
+ _Int(uint64_t __lo) noexcept : _M_hi(0)
+ { _M_lo = __lo; }
+
+ constexpr bool operator==(const _Int&) const = default;
+# 781 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+ constexpr _Int&
+ operator^=(const _Int& __rhs) noexcept
+ {
+ _M_hi ^= __rhs._M_hi;
+ _M_lo ^= __rhs._M_lo;
+ return *this;
+ }
+
+ constexpr strong_ordering
+ operator<=>(const _Int& __rhs) const noexcept
+ {
+ strong_ordering __cmp = _M_hi <=> __rhs._M_hi;
+ if (__cmp != strong_ordering::equal)
+ return __cmp;
+ return _M_lo <=> __rhs._M_lo;
+ }
+ };
+
+ template<typename _Tp>
+ static constexpr _Tp
+ _S_compl(_Tp __t) noexcept
+ {
+ constexpr int __width = sizeof(_Tp) * 8;
+
+ make_unsigned_t<_Tp> __sign = __t >> (__width - 1);
+
+
+ return __t ^ (__sign >> 1);
+ }
+
+
+ template<typename _Tp>
+ static constexpr _Int<_Tp>
+ _S_compl(_Int<_Tp> __t) noexcept
+ {
+ constexpr int __width = sizeof(_Tp) * 8;
+ make_unsigned_t<_Tp> __sign = __t._M_hi >> (__width - 1);
+ __t._M_hi ^= (__sign >> 1 );
+ uint64_t __sign64 = (_Tp)__sign;
+ __t._M_lo ^= __sign64;
+ return __t;
+ }
+
+
+ template<typename _Tp>
+ constexpr static auto
+ _S_fp_bits(_Tp __val) noexcept
+ {
+ if constexpr (sizeof(_Tp) == sizeof(int64_t))
+ return __builtin_bit_cast(int64_t, __val);
+ else if constexpr (sizeof(_Tp) == sizeof(int32_t))
+ return __builtin_bit_cast(int32_t, __val);
+ else if constexpr (sizeof(_Tp) == sizeof(int16_t))
+ return __builtin_bit_cast(int16_t, __val);
+ else
+ {
+
+ using enum _Fp_fmt;
+
+ constexpr auto __fmt = _S_fp_fmt<_Tp>();
+ if constexpr (__fmt == _X86_80bit || __fmt == _M68k_80bit)
+ {
+ if constexpr (sizeof(_Tp) == 3 * sizeof(int32_t))
+ {
+ auto __ival = __builtin_bit_cast(_Int<int32_t>, __val);
+ return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
+ }
+ else
+ {
+ auto __ival = __builtin_bit_cast(_Int<int64_t>, __val);
+ return _Int<int16_t>(__ival._M_hi, __ival._M_lo);
+ }
+ }
+ else if constexpr (sizeof(_Tp) == 2 * sizeof(int64_t))
+ {
+
+ return __builtin_bit_cast(__int128, __val);
+
+
+
+ }
+ else
+ static_assert(sizeof(_Tp) == sizeof(int64_t),
+ "unsupported floating-point type");
+ }
+ }
+
+ template<typename _Tp>
+ static constexpr strong_ordering
+ _S_fp_cmp(_Tp __x, _Tp __y) noexcept
+ {
+# 885 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+ auto __ix = _S_fp_bits(__x);
+ auto __iy = _S_fp_bits(__y);
+
+ if (__ix == __iy)
+ return strong_ordering::equal;
+
+
+ using enum _Fp_fmt;
+
+ constexpr auto __fmt = _S_fp_fmt<_Tp>();
+
+ if constexpr (__fmt == _Dbldbl)
+ {
+
+
+ struct _Unpacked { double _M_hi; int64_t _M_lo; };
+ auto __x2 = __builtin_bit_cast(_Unpacked, __x);
+ auto __y2 = __builtin_bit_cast(_Unpacked, __y);
+
+
+ auto __cmp = _S_fp_cmp(__x2._M_hi, __y2._M_hi);
+ if (__cmp != strong_ordering::equal)
+ return __cmp;
+
+
+
+ if (__builtin_isnan(__x2._M_hi))
+ return strong_ordering::equal;
+
+
+ if (((__x2._M_lo | __y2._M_lo) & 0x7fffffffffffffffULL) == 0)
+ return strong_ordering::equal;
+
+
+ return _S_compl(__x2._M_lo) <=> _S_compl(__y2._M_lo);
+ }
+ else
+ {
+ if constexpr (__fmt == _M68k_80bit)
+ {
+
+
+
+ constexpr uint16_t __maxexp = 0x7fff;
+ if ((__ix._M_hi & __maxexp) == __maxexp)
+ __ix._M_lo |= 1ull << 63;
+ if ((__iy._M_hi & __maxexp) == __maxexp)
+ __iy._M_lo |= 1ull << 63;
+ }
+ else
+ {
+# 952 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/compare" 3
+ }
+ return _S_compl(__ix) <=> _S_compl(__iy);
+ }
+ }
+
+ public:
+ template<typename _Tp, __decayed_same_as<_Tp> _Up>
+ requires __strongly_ordered<_Tp, _Up>
+ constexpr strong_ordering
+ operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (floating_point<decay_t<_Tp>>)
+ return _S_fp_cmp(__e, __f);
+ else if constexpr (__adl_strong<_Tp, _Up>)
+ return strong_ordering(strong_order(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f)));
+ else if constexpr (__cmp3way<strong_ordering, _Tp, _Up>)
+ return compare_three_way()(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ }
+ };
+
+ template<typename _Tp, typename _Up>
+ concept __weakly_ordered
+ = floating_point<remove_reference_t<_Tp>>
+ || __adl_weak<_Tp, _Up>
+ || __cmp3way<weak_ordering, _Tp, _Up>
+ || __strongly_ordered<_Tp, _Up>;
+
+ class _Weak_order
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (floating_point<decay_t<_Tp>>)
+ return true;
+ else if constexpr (__adl_weak<_Tp, _Up>)
+ return noexcept(weak_ordering(weak_order(std::declval<_Tp>(),
+ std::declval<_Up>())));
+ else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
+ return noexcept(compare_three_way()(std::declval<_Tp>(),
+ std::declval<_Up>()));
+ else if constexpr (__strongly_ordered<_Tp, _Up>)
+ return _Strong_order::_S_noexcept<_Tp, _Up>();
+ }
+
+ friend class _Partial_order;
+ friend class _Weak_fallback;
+
+ public:
+ template<typename _Tp, __decayed_same_as<_Tp> _Up>
+ requires __weakly_ordered<_Tp, _Up>
+ constexpr weak_ordering
+ operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (floating_point<decay_t<_Tp>>)
+ return __compare::__fp_weak_ordering(__e, __f);
+ else if constexpr (__adl_weak<_Tp, _Up>)
+ return weak_ordering(weak_order(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f)));
+ else if constexpr (__cmp3way<weak_ordering, _Tp, _Up>)
+ return compare_three_way()(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ else if constexpr (__strongly_ordered<_Tp, _Up>)
+ return _Strong_order{}(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ }
+ };
+
+ template<typename _Tp, typename _Up>
+ concept __partially_ordered
+ = __adl_partial<_Tp, _Up>
+ || __cmp3way<partial_ordering, _Tp, _Up>
+ || __weakly_ordered<_Tp, _Up>;
+
+ class _Partial_order
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (__adl_partial<_Tp, _Up>)
+ return noexcept(partial_ordering(partial_order(std::declval<_Tp>(),
+ std::declval<_Up>())));
+ else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
+ return noexcept(compare_three_way()(std::declval<_Tp>(),
+ std::declval<_Up>()));
+ else if constexpr (__weakly_ordered<_Tp, _Up>)
+ return _Weak_order::_S_noexcept<_Tp, _Up>();
+ }
+
+ friend class _Partial_fallback;
+
+ public:
+ template<typename _Tp, __decayed_same_as<_Tp> _Up>
+ requires __partially_ordered<_Tp, _Up>
+ constexpr partial_ordering
+ operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (__adl_partial<_Tp, _Up>)
+ return partial_ordering(partial_order(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f)));
+ else if constexpr (__cmp3way<partial_ordering, _Tp, _Up>)
+ return compare_three_way()(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ else if constexpr (__weakly_ordered<_Tp, _Up>)
+ return _Weak_order{}(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ }
+ };
+
+ template<typename _Tp, typename _Up>
+ concept __op_eq_lt = requires(_Tp&& __t, _Up&& __u)
+ {
+ { static_cast<_Tp&&>(__t) == static_cast<_Up&&>(__u) }
+ -> convertible_to<bool>;
+ { static_cast<_Tp&&>(__t) < static_cast<_Up&&>(__u) }
+ -> convertible_to<bool>;
+ };
+
+ class _Strong_fallback
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (__strongly_ordered<_Tp, _Up>)
+ return _Strong_order::_S_noexcept<_Tp, _Up>();
+ else
+ return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
+ && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
+ }
+
+ public:
+ template<typename _Tp, __decayed_same_as<_Tp> _Up>
+ requires __strongly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
+ constexpr strong_ordering
+ operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (__strongly_ordered<_Tp, _Up>)
+ return _Strong_order{}(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ else
+ return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
+ ? strong_ordering::equal
+ : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
+ ? strong_ordering::less
+ : strong_ordering::greater;
+ }
+ };
+
+ class _Weak_fallback
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (__weakly_ordered<_Tp, _Up>)
+ return _Weak_order::_S_noexcept<_Tp, _Up>();
+ else
+ return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
+ && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
+ }
+
+ public:
+ template<typename _Tp, __decayed_same_as<_Tp> _Up>
+ requires __weakly_ordered<_Tp, _Up> || __op_eq_lt<_Tp, _Up>
+ constexpr weak_ordering
+ operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (__weakly_ordered<_Tp, _Up>)
+ return _Weak_order{}(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ else
+ return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
+ ? weak_ordering::equivalent
+ : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
+ ? weak_ordering::less
+ : weak_ordering::greater;
+ }
+ };
+
+
+
+ template<typename _Tp, typename _Up>
+ concept __op_eq_lt_lt = __op_eq_lt<_Tp, _Up>
+ && requires(_Tp&& __t, _Up&& __u)
+ {
+ { static_cast<_Up&&>(__u) < static_cast<_Tp&&>(__t) }
+ -> convertible_to<bool>;
+ };
+
+ class _Partial_fallback
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept()
+ {
+ if constexpr (__partially_ordered<_Tp, _Up>)
+ return _Partial_order::_S_noexcept<_Tp, _Up>();
+ else
+ return noexcept(bool(std::declval<_Tp>() == std::declval<_Up>()))
+ && noexcept(bool(std::declval<_Tp>() < std::declval<_Up>()));
+ }
+
+ public:
+ template<typename _Tp, __decayed_same_as<_Tp> _Up>
+ requires __partially_ordered<_Tp, _Up> || __op_eq_lt_lt<_Tp, _Up>
+ constexpr partial_ordering
+ operator() [[nodiscard]] (_Tp&& __e, _Up&& __f) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ {
+ if constexpr (__partially_ordered<_Tp, _Up>)
+ return _Partial_order{}(static_cast<_Tp&&>(__e),
+ static_cast<_Up&&>(__f));
+ else
+ return static_cast<_Tp&&>(__e) == static_cast<_Up&&>(__f)
+ ? partial_ordering::equivalent
+ : static_cast<_Tp&&>(__e) < static_cast<_Up&&>(__f)
+ ? partial_ordering::less
+ : static_cast<_Up&&>(__f) < static_cast<_Tp&&>(__e)
+ ? partial_ordering::greater
+ : partial_ordering::unordered;
+ }
+ };
+ }
+
+
+
+ inline namespace _Cpo
+ {
+ inline constexpr __compare::_Strong_order strong_order{};
+
+ inline constexpr __compare::_Weak_order weak_order{};
+
+ inline constexpr __compare::_Partial_order partial_order{};
+
+ inline constexpr __compare::_Strong_fallback
+ compare_strong_order_fallback{};
+
+ inline constexpr __compare::_Weak_fallback
+ compare_weak_order_fallback{};
+
+ inline constexpr __compare::_Partial_fallback
+ compare_partial_order_fallback{};
+ }
+
+
+ namespace __detail
+ {
+
+ inline constexpr struct _Synth3way
+ {
+ template<typename _Tp, typename _Up>
+ static constexpr bool
+ _S_noexcept(const _Tp* __t = nullptr, const _Up* __u = nullptr)
+ {
+ if constexpr (three_way_comparable_with<_Tp, _Up>)
+ return noexcept(*__t <=> *__u);
+ else
+ return noexcept(*__t < *__u) && noexcept(*__u < *__t);
+ }
+
+ template<typename _Tp, typename _Up>
+ [[nodiscard]]
+ constexpr auto
+ operator()(const _Tp& __t, const _Up& __u) const
+ noexcept(_S_noexcept<_Tp, _Up>())
+ requires requires
+ {
+ { __t < __u } -> __boolean_testable;
+ { __u < __t } -> __boolean_testable;
+ }
+ {
+ if constexpr (three_way_comparable_with<_Tp, _Up>)
+ return __t <=> __u;
+ else
+ {
+ if (__t < __u)
+ return weak_ordering::less;
+ else if (__u < __t)
+ return weak_ordering::greater;
+ else
+ return weak_ordering::equivalent;
+ }
+ }
+ } __synth3way = {};
+
+
+ template<typename _Tp, typename _Up = _Tp>
+ using __synth3way_t
+ = decltype(__detail::__synth3way(std::declval<_Tp&>(),
+ std::declval<_Up&>()));
+ }
+
+
+}
+# 66 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 2 3
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+# 79 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ struct piecewise_construct_t { explicit piecewise_construct_t() = default; };
+
+
+ inline constexpr piecewise_construct_t piecewise_construct =
+ piecewise_construct_t();
+
+
+
+
+ template<typename _T1, typename _T2>
+ struct pair;
+
+ template<typename...>
+ class tuple;
+
+
+
+
+
+ template<typename _Tp, size_t _Nm>
+ struct array;
+
+ template<size_t...>
+ struct _Index_tuple;
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
+ get(pair<_Tp1, _Tp2>& __in) noexcept;
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
+ get(pair<_Tp1, _Tp2>&& __in) noexcept;
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
+ get(const pair<_Tp1, _Tp2>& __in) noexcept;
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
+ get(const pair<_Tp1, _Tp2>&& __in) noexcept;
+
+ template<size_t __i, typename... _Elements>
+ constexpr __tuple_element_t<__i, tuple<_Elements...>>&
+ get(tuple<_Elements...>& __t) noexcept;
+
+ template<size_t __i, typename... _Elements>
+ constexpr const __tuple_element_t<__i, tuple<_Elements...>>&
+ get(const tuple<_Elements...>& __t) noexcept;
+
+ template<size_t __i, typename... _Elements>
+ constexpr __tuple_element_t<__i, tuple<_Elements...>>&&
+ get(tuple<_Elements...>&& __t) noexcept;
+
+ template<size_t __i, typename... _Elements>
+ constexpr const __tuple_element_t<__i, tuple<_Elements...>>&&
+ get(const tuple<_Elements...>&& __t) noexcept;
+
+ template<size_t _Int, typename _Tp, size_t _Nm>
+ constexpr _Tp&
+ get(array<_Tp, _Nm>&) noexcept;
+
+ template<size_t _Int, typename _Tp, size_t _Nm>
+ constexpr _Tp&&
+ get(array<_Tp, _Nm>&&) noexcept;
+
+ template<size_t _Int, typename _Tp, size_t _Nm>
+ constexpr const _Tp&
+ get(const array<_Tp, _Nm>&) noexcept;
+
+ template<size_t _Int, typename _Tp, size_t _Nm>
+ constexpr const _Tp&&
+ get(const array<_Tp, _Nm>&&) noexcept;
+# 260 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _U1, typename _U2> class __pair_base
+ {
+
+
+
+
+
+
+
+ };
+# 283 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _T1, typename _T2>
+ struct pair
+ : public __pair_base<_T1, _T2>
+ {
+ typedef _T1 first_type;
+ typedef _T2 second_type;
+
+ _T1 first;
+ _T2 second;
+
+
+ constexpr pair(const pair&) = default;
+ constexpr pair(pair&&) = default;
+
+ template<typename... _Args1, typename... _Args2>
+ constexpr
+ pair(piecewise_construct_t, tuple<_Args1...>, tuple<_Args2...>);
+
+
+ constexpr void
+ swap(pair& __p)
+ noexcept(__and_<__is_nothrow_swappable<_T1>,
+ __is_nothrow_swappable<_T2>>::value)
+ {
+ using std::swap;
+ swap(first, __p.first);
+ swap(second, __p.second);
+ }
+# 331 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ private:
+ template<typename... _Args1, size_t... _Indexes1,
+ typename... _Args2, size_t... _Indexes2>
+ constexpr
+ pair(tuple<_Args1...>&, tuple<_Args2...>&,
+ _Index_tuple<_Indexes1...>, _Index_tuple<_Indexes2...>);
+ public:
+
+
+
+
+
+ constexpr
+ explicit(__not_<__and_<__is_implicitly_default_constructible<_T1>,
+ __is_implicitly_default_constructible<_T2>>>())
+ pair()
+ requires is_default_constructible_v<_T1>
+ && is_default_constructible_v<_T2>
+ : first(), second()
+ { }
+
+ private:
+
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_constructible()
+ {
+ if constexpr (is_constructible_v<_T1, _U1>)
+ return is_constructible_v<_T2, _U2>;
+ return false;
+ }
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_nothrow_constructible()
+ {
+ if constexpr (is_nothrow_constructible_v<_T1, _U1>)
+ return is_nothrow_constructible_v<_T2, _U2>;
+ return false;
+ }
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_convertible()
+ {
+ if constexpr (is_convertible_v<_U1, _T1>)
+ return is_convertible_v<_U2, _T2>;
+ return false;
+ }
+
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_dangles()
+ {
+
+ if constexpr (__reference_constructs_from_temporary(_T1, _U1&&))
+ return true;
+ else
+ return __reference_constructs_from_temporary(_T2, _U2&&);
+
+
+
+ }
+# 424 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ public:
+
+
+ constexpr explicit(!_S_convertible<const _T1&, const _T2&>())
+ pair(const _T1& __x, const _T2& __y)
+ noexcept(_S_nothrow_constructible<const _T1&, const _T2&>())
+ requires (_S_constructible<const _T1&, const _T2&>())
+ : first(__x), second(__y)
+ { }
+
+
+
+
+
+ template<typename _U1, typename _U2>
+
+ requires (_S_constructible<_U1, _U2>()) && (!_S_dangles<_U1, _U2>())
+ constexpr explicit(!_S_convertible<_U1, _U2>())
+ pair(_U1&& __x, _U2&& __y)
+ noexcept(_S_nothrow_constructible<_U1, _U2>())
+ : first(std::forward<_U1>(__x)), second(std::forward<_U2>(__y))
+ { }
+
+
+
+
+ template<typename _U1, typename _U2>
+
+ requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())
+ constexpr explicit(!_S_convertible<_U1, _U2>())
+ pair(_U1&&, _U2&&) = delete;
+
+
+ template<typename _U1, typename _U2>
+ requires (_S_constructible<const _U1&, const _U2&>())
+ && (!_S_dangles<_U1, _U2>())
+ constexpr explicit(!_S_convertible<const _U1&, const _U2&>())
+ pair(const pair<_U1, _U2>& __p)
+ noexcept(_S_nothrow_constructible<const _U1&, const _U2&>())
+ : first(__p.first), second(__p.second)
+ { }
+
+ template<typename _U1, typename _U2>
+ requires (_S_constructible<const _U1&, const _U2&>())
+ && (_S_dangles<const _U1&, const _U2&>())
+ constexpr explicit(!_S_convertible<const _U1&, const _U2&>())
+ pair(const pair<_U1, _U2>&) = delete;
+
+
+ template<typename _U1, typename _U2>
+ requires (_S_constructible<_U1, _U2>()) && (!_S_dangles<_U1, _U2>())
+ constexpr explicit(!_S_convertible<_U1, _U2>())
+ pair(pair<_U1, _U2>&& __p)
+ noexcept(_S_nothrow_constructible<_U1, _U2>())
+ : first(std::forward<_U1>(__p.first)),
+ second(std::forward<_U2>(__p.second))
+ { }
+
+ template<typename _U1, typename _U2>
+ requires (_S_constructible<_U1, _U2>()) && (_S_dangles<_U1, _U2>())
+ constexpr explicit(!_S_convertible<_U1, _U2>())
+ pair(pair<_U1, _U2>&&) = delete;
+# 537 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ private:
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_assignable()
+ {
+ if constexpr (is_assignable_v<_T1&, _U1>)
+ return is_assignable_v<_T2&, _U2>;
+ return false;
+ }
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_const_assignable()
+ {
+ if constexpr (is_assignable_v<const _T1&, _U1>)
+ return is_assignable_v<const _T2&, _U2>;
+ return false;
+ }
+
+ template<typename _U1, typename _U2>
+ static constexpr bool
+ _S_nothrow_assignable()
+ {
+ if constexpr (is_nothrow_assignable_v<_T1&, _U1>)
+ return is_nothrow_assignable_v<_T2&, _U2>;
+ return false;
+ }
+# 585 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ public:
+
+ pair& operator=(const pair&) = delete;
+
+
+ constexpr pair&
+ operator=(const pair& __p)
+ noexcept(_S_nothrow_assignable<const _T1&, const _T2&>())
+ requires (_S_assignable<const _T1&, const _T2&>())
+ {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+ }
+
+
+ constexpr pair&
+ operator=(pair&& __p)
+ noexcept(_S_nothrow_assignable<_T1, _T2>())
+ requires (_S_assignable<_T1, _T2>())
+ {
+ first = std::forward<first_type>(__p.first);
+ second = std::forward<second_type>(__p.second);
+ return *this;
+ }
+
+
+ template<typename _U1, typename _U2>
+ constexpr pair&
+ operator=(const pair<_U1, _U2>& __p)
+ noexcept(_S_nothrow_assignable<const _U1&, const _U2&>())
+ requires (_S_assignable<const _U1&, const _U2&>())
+ {
+ first = __p.first;
+ second = __p.second;
+ return *this;
+ }
+
+
+ template<typename _U1, typename _U2>
+ constexpr pair&
+ operator=(pair<_U1, _U2>&& __p)
+ noexcept(_S_nothrow_assignable<_U1, _U2>())
+ requires (_S_assignable<_U1, _U2>())
+ {
+ first = std::forward<_U1>(__p.first);
+ second = std::forward<_U2>(__p.second);
+ return *this;
+ }
+# 995 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ };
+
+
+
+
+ template<typename _T1, typename _T2> pair(_T1, _T2) -> pair<_T1, _T2>;
+
+
+
+
+
+
+
+ template<typename _T1, typename _T2, typename _U1, typename _U2>
+ inline constexpr bool
+ operator==(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
+ { return __x.first == __y.first && __x.second == __y.second; }
+# 1020 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _T1, typename _T2, typename _U1, typename _U2>
+ constexpr common_comparison_category_t<__detail::__synth3way_t<_T1, _U1>,
+ __detail::__synth3way_t<_T2, _U2>>
+ operator<=>(const pair<_T1, _T2>& __x, const pair<_U1, _U2>& __y)
+ {
+ if (auto __c = __detail::__synth3way(__x.first, __y.first); __c != 0)
+ return __c;
+ return __detail::__synth3way(__x.second, __y.second);
+ }
+# 1080 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _T1, typename _T2>
+ constexpr inline
+
+
+ typename enable_if<__and_<__is_swappable<_T1>,
+ __is_swappable<_T2>>::value>::type
+
+
+
+ swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
+ noexcept(noexcept(__x.swap(__y)))
+ { __x.swap(__y); }
+# 1103 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _T1, typename _T2>
+ typename enable_if<!__and_<__is_swappable<_T1>,
+ __is_swappable<_T2>>::value>::type
+ swap(pair<_T1, _T2>&, pair<_T1, _T2>&) = delete;
+# 1129 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _T1, typename _T2>
+ constexpr pair<typename __decay_and_strip<_T1>::__type,
+ typename __decay_and_strip<_T2>::__type>
+ make_pair(_T1&& __x, _T2&& __y)
+ {
+ typedef typename __decay_and_strip<_T1>::__type __ds_type1;
+ typedef typename __decay_and_strip<_T2>::__type __ds_type2;
+ typedef pair<__ds_type1, __ds_type2> __pair_type;
+ return __pair_type(std::forward<_T1>(__x), std::forward<_T2>(__y));
+ }
+# 1152 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+ template<typename _T1, typename _T2>
+ struct __is_tuple_like_impl<pair<_T1, _T2>> : true_type
+ { };
+
+
+
+ template<class _Tp1, class _Tp2>
+ struct tuple_size<pair<_Tp1, _Tp2>>
+ : public integral_constant<size_t, 2> { };
+
+
+ template<class _Tp1, class _Tp2>
+ struct tuple_element<0, pair<_Tp1, _Tp2>>
+ { typedef _Tp1 type; };
+
+
+ template<class _Tp1, class _Tp2>
+ struct tuple_element<1, pair<_Tp1, _Tp2>>
+ { typedef _Tp2 type; };
+
+
+
+ template<size_t __i, typename... _Types>
+ struct tuple_element<__i, tuple<_Types...>>;
+
+
+ template<typename _Tp1, typename _Tp2>
+ inline constexpr size_t tuple_size_v<pair<_Tp1, _Tp2>> = 2;
+
+ template<typename _Tp1, typename _Tp2>
+ inline constexpr size_t tuple_size_v<const pair<_Tp1, _Tp2>> = 2;
+
+ template<typename _Tp>
+ inline constexpr bool __is_pair = false;
+
+ template<typename _Tp, typename _Up>
+ inline constexpr bool __is_pair<pair<_Tp, _Up>> = true;
+
+
+
+ template<size_t _Int>
+ struct __pair_get;
+
+ template<>
+ struct __pair_get<0>
+ {
+ template<typename _Tp1, typename _Tp2>
+ static constexpr _Tp1&
+ __get(pair<_Tp1, _Tp2>& __pair) noexcept
+ { return __pair.first; }
+
+ template<typename _Tp1, typename _Tp2>
+ static constexpr _Tp1&&
+ __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
+ { return std::forward<_Tp1>(__pair.first); }
+
+ template<typename _Tp1, typename _Tp2>
+ static constexpr const _Tp1&
+ __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
+ { return __pair.first; }
+
+ template<typename _Tp1, typename _Tp2>
+ static constexpr const _Tp1&&
+ __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
+ { return std::forward<const _Tp1>(__pair.first); }
+ };
+
+ template<>
+ struct __pair_get<1>
+ {
+ template<typename _Tp1, typename _Tp2>
+ static constexpr _Tp2&
+ __get(pair<_Tp1, _Tp2>& __pair) noexcept
+ { return __pair.second; }
+
+ template<typename _Tp1, typename _Tp2>
+ static constexpr _Tp2&&
+ __move_get(pair<_Tp1, _Tp2>&& __pair) noexcept
+ { return std::forward<_Tp2>(__pair.second); }
+
+ template<typename _Tp1, typename _Tp2>
+ static constexpr const _Tp2&
+ __const_get(const pair<_Tp1, _Tp2>& __pair) noexcept
+ { return __pair.second; }
+
+ template<typename _Tp1, typename _Tp2>
+ static constexpr const _Tp2&&
+ __const_move_get(const pair<_Tp1, _Tp2>&& __pair) noexcept
+ { return std::forward<const _Tp2>(__pair.second); }
+ };
+
+
+
+
+
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
+ get(pair<_Tp1, _Tp2>& __in) noexcept
+ { return __pair_get<_Int>::__get(__in); }
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
+ get(pair<_Tp1, _Tp2>&& __in) noexcept
+ { return __pair_get<_Int>::__move_get(std::move(__in)); }
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&
+ get(const pair<_Tp1, _Tp2>& __in) noexcept
+ { return __pair_get<_Int>::__const_get(__in); }
+
+ template<size_t _Int, class _Tp1, class _Tp2>
+ constexpr const typename tuple_element<_Int, pair<_Tp1, _Tp2>>::type&&
+ get(const pair<_Tp1, _Tp2>&& __in) noexcept
+ { return __pair_get<_Int>::__const_move_get(std::move(__in)); }
+
+
+
+ template <typename _Tp, typename _Up>
+ constexpr _Tp&
+ get(pair<_Tp, _Up>& __p) noexcept
+ { return __p.first; }
+
+ template <typename _Tp, typename _Up>
+ constexpr const _Tp&
+ get(const pair<_Tp, _Up>& __p) noexcept
+ { return __p.first; }
+
+ template <typename _Tp, typename _Up>
+ constexpr _Tp&&
+ get(pair<_Tp, _Up>&& __p) noexcept
+ { return std::move(__p.first); }
+
+ template <typename _Tp, typename _Up>
+ constexpr const _Tp&&
+ get(const pair<_Tp, _Up>&& __p) noexcept
+ { return std::move(__p.first); }
+
+ template <typename _Tp, typename _Up>
+ constexpr _Tp&
+ get(pair<_Up, _Tp>& __p) noexcept
+ { return __p.second; }
+
+ template <typename _Tp, typename _Up>
+ constexpr const _Tp&
+ get(const pair<_Up, _Tp>& __p) noexcept
+ { return __p.second; }
+
+ template <typename _Tp, typename _Up>
+ constexpr _Tp&&
+ get(pair<_Up, _Tp>&& __p) noexcept
+ { return std::move(__p.second); }
+
+ template <typename _Tp, typename _Up>
+ constexpr const _Tp&&
+ get(const pair<_Up, _Tp>&& __p) noexcept
+ { return std::move(__p.second); }
+# 1333 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/stl_pair.h" 3
+}
+# 70 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 2 3
+
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/initializer_list" 1 3
+# 34 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/initializer_list" 3
+
+
+
+
+
+
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+ template<class _E>
+ class initializer_list
+ {
+ public:
+ typedef _E value_type;
+ typedef const _E& reference;
+ typedef const _E& const_reference;
+ typedef size_t size_type;
+ typedef const _E* iterator;
+ typedef const _E* const_iterator;
+
+ private:
+ iterator _M_array;
+ size_type _M_len;
+
+
+ constexpr initializer_list(const_iterator __a, size_type __l)
+ : _M_array(__a), _M_len(__l) { }
+
+ public:
+ constexpr initializer_list() noexcept
+ : _M_array(0), _M_len(0) { }
+
+
+ constexpr size_type
+ size() const noexcept { return _M_len; }
+
+
+ constexpr const_iterator
+ begin() const noexcept { return _M_array; }
+
+
+ constexpr const_iterator
+ end() const noexcept { return begin() + size(); }
+ };
+
+
+
+
+
+
+
+ template<class _Tp>
+ constexpr const _Tp*
+ begin(initializer_list<_Tp> __ils) noexcept
+ { return __ils.begin(); }
+
+
+
+
+
+
+
+ template<class _Tp>
+ constexpr const _Tp*
+ end(initializer_list<_Tp> __ils) noexcept
+ { return __ils.end(); }
+}
+# 74 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 2 3
+
+
+
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 1 3
+# 33 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 3
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 1 3
+# 36 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 3
+
+
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 1 3
+# 48 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 3
+# 39 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 2 3
+# 68 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 3
+extern "C++" {
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+ struct __true_type { };
+ struct __false_type { };
+
+ template<bool>
+ struct __truth_type
+ { typedef __false_type __type; };
+
+ template<>
+ struct __truth_type<true>
+ { typedef __true_type __type; };
+
+
+
+ template<class _Sp, class _Tp>
+ struct __traitor
+ {
+ enum { __value = bool(_Sp::__value) || bool(_Tp::__value) };
+ typedef typename __truth_type<__value>::__type __type;
+ };
+
+
+ template<typename, typename>
+ struct __are_same
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+ template<typename _Tp>
+ struct __are_same<_Tp, _Tp>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ template<typename _Tp>
+ struct __is_void
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+ template<>
+ struct __is_void<void>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+
+
+ template<typename _Tp>
+ struct __is_integer
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+
+
+
+
+ template<>
+ struct __is_integer<bool>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<signed char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<unsigned char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ template<>
+ struct __is_integer<wchar_t>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+
+ template<>
+ struct __is_integer<char8_t>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+
+ template<>
+ struct __is_integer<char16_t>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<char32_t>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ template<>
+ struct __is_integer<short>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<unsigned short>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<int>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<unsigned int>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<long>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<unsigned long>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<long long>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_integer<unsigned long long>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+# 290 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 3
+ template<typename _Tp>
+ struct __is_floating
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+
+ template<>
+ struct __is_floating<float>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_floating<double>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_floating<long double>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+# 367 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 3
+ template<typename _Tp>
+ struct __is_pointer
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+ template<typename _Tp>
+ struct __is_pointer<_Tp*>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+
+
+ template<typename _Tp>
+ struct __is_arithmetic
+ : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> >
+ { };
+
+
+
+
+ template<typename _Tp>
+ struct __is_scalar
+ : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> >
+ { };
+
+
+
+
+ template<typename _Tp>
+ struct __is_char
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+ template<>
+ struct __is_char<char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ template<>
+ struct __is_char<wchar_t>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ template<typename _Tp>
+ struct __is_byte
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+ template<>
+ struct __is_byte<char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_byte<signed char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+ template<>
+ struct __is_byte<unsigned char>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ enum class byte : unsigned char;
+
+ template<>
+ struct __is_byte<byte>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+
+ template<>
+ struct __is_byte<char8_t>
+ {
+ enum { __value = 1 };
+ typedef __true_type __type;
+ };
+
+
+ template<typename> struct iterator_traits;
+
+
+ template<typename _Tp>
+ struct __is_nonvolatile_trivially_copyable
+ {
+ enum { __value = __is_trivially_copyable(_Tp) };
+ };
+
+
+
+
+ template<typename _Tp>
+ struct __is_nonvolatile_trivially_copyable<volatile _Tp>
+ {
+ enum { __value = 0 };
+ };
+
+
+ template<typename _OutputIter, typename _InputIter>
+ struct __memcpyable
+ {
+ enum { __value = 0 };
+ };
+
+ template<typename _Tp>
+ struct __memcpyable<_Tp*, _Tp*>
+ : __is_nonvolatile_trivially_copyable<_Tp>
+ { };
+
+ template<typename _Tp>
+ struct __memcpyable<_Tp*, const _Tp*>
+ : __is_nonvolatile_trivially_copyable<_Tp>
+ { };
+
+
+
+
+
+
+ template<typename _Iter1, typename _Iter2>
+ struct __memcmpable
+ {
+ enum { __value = 0 };
+ };
+
+
+ template<typename _Tp>
+ struct __memcmpable<_Tp*, _Tp*>
+ : __is_nonvolatile_trivially_copyable<_Tp>
+ { };
+
+ template<typename _Tp>
+ struct __memcmpable<const _Tp*, _Tp*>
+ : __is_nonvolatile_trivially_copyable<_Tp>
+ { };
+
+ template<typename _Tp>
+ struct __memcmpable<_Tp*, const _Tp*>
+ : __is_nonvolatile_trivially_copyable<_Tp>
+ { };
+
+
+
+
+
+
+
+ template<typename _Tp, bool _TreatAsBytes =
+
+
+
+ __is_byte<_Tp>::__value
+
+ >
+ struct __is_memcmp_ordered
+ {
+ static const bool __value = _Tp(-1) > _Tp(1);
+ };
+
+ template<typename _Tp>
+ struct __is_memcmp_ordered<_Tp, false>
+ {
+ static const bool __value = false;
+ };
+
+
+ template<typename _Tp, typename _Up, bool = sizeof(_Tp) == sizeof(_Up)>
+ struct __is_memcmp_ordered_with
+ {
+ static const bool __value = __is_memcmp_ordered<_Tp>::__value
+ && __is_memcmp_ordered<_Up>::__value;
+ };
+
+ template<typename _Tp, typename _Up>
+ struct __is_memcmp_ordered_with<_Tp, _Up, false>
+ {
+ static const bool __value = false;
+ };
+# 580 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/cpp_type_traits.h" 3
+ template<>
+ struct __is_memcmp_ordered_with<std::byte, std::byte, true>
+ { static constexpr bool __value = true; };
+
+ template<typename _Tp, bool _SameSize>
+ struct __is_memcmp_ordered_with<_Tp, std::byte, _SameSize>
+ { static constexpr bool __value = false; };
+
+ template<typename _Up, bool _SameSize>
+ struct __is_memcmp_ordered_with<std::byte, _Up, _SameSize>
+ { static constexpr bool __value = false; };
+
+
+
+
+
+ template<typename _Tp>
+ struct __is_move_iterator
+ {
+ enum { __value = 0 };
+ typedef __false_type __type;
+ };
+
+
+
+ template<typename _Iterator>
+ constexpr
+ inline _Iterator
+ __miter_base(_Iterator __it)
+ { return __it; }
+
+
+}
+}
+# 35 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 2 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/type_traits.h" 1 3
+# 33 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/type_traits.h" 3
+
+
+
+
+extern "C++" {
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+ template<bool, typename>
+ struct __enable_if
+ { };
+
+ template<typename _Tp>
+ struct __enable_if<true, _Tp>
+ { typedef _Tp __type; };
+
+
+
+ template<bool _Cond, typename _Iftrue, typename _Iffalse>
+ struct __conditional_type
+ { typedef _Iftrue __type; };
+
+ template<typename _Iftrue, typename _Iffalse>
+ struct __conditional_type<false, _Iftrue, _Iffalse>
+ { typedef _Iffalse __type; };
+
+
+
+ template<typename _Tp>
+ struct __add_unsigned
+ {
+ private:
+ typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+
+ public:
+ typedef typename __if_type::__type __type;
+ };
+
+ template<>
+ struct __add_unsigned<char>
+ { typedef unsigned char __type; };
+
+ template<>
+ struct __add_unsigned<signed char>
+ { typedef unsigned char __type; };
+
+ template<>
+ struct __add_unsigned<short>
+ { typedef unsigned short __type; };
+
+ template<>
+ struct __add_unsigned<int>
+ { typedef unsigned int __type; };
+
+ template<>
+ struct __add_unsigned<long>
+ { typedef unsigned long __type; };
+
+ template<>
+ struct __add_unsigned<long long>
+ { typedef unsigned long long __type; };
+
+
+ template<>
+ struct __add_unsigned<bool>;
+
+ template<>
+ struct __add_unsigned<wchar_t>;
+
+
+
+ template<typename _Tp>
+ struct __remove_unsigned
+ {
+ private:
+ typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type;
+
+ public:
+ typedef typename __if_type::__type __type;
+ };
+
+ template<>
+ struct __remove_unsigned<char>
+ { typedef signed char __type; };
+
+ template<>
+ struct __remove_unsigned<unsigned char>
+ { typedef signed char __type; };
+
+ template<>
+ struct __remove_unsigned<unsigned short>
+ { typedef short __type; };
+
+ template<>
+ struct __remove_unsigned<unsigned int>
+ { typedef int __type; };
+
+ template<>
+ struct __remove_unsigned<unsigned long>
+ { typedef long __type; };
+
+ template<>
+ struct __remove_unsigned<unsigned long long>
+ { typedef long long __type; };
+
+
+ template<>
+ struct __remove_unsigned<bool>;
+
+ template<>
+ struct __remove_unsigned<wchar_t>;
+
+
+
+ template<typename _Type>
+ constexpr
+ inline bool
+ __is_null_pointer(_Type* __ptr)
+ { return __ptr == 0; }
+
+ template<typename _Type>
+ constexpr
+ inline bool
+ __is_null_pointer(_Type)
+ { return false; }
+
+
+ constexpr bool
+ __is_null_pointer(std::nullptr_t)
+ { return true; }
+
+
+
+
+ template<typename _Tp, bool = std::__is_integer<_Tp>::__value>
+ struct __promote
+ { typedef double __type; };
+
+
+
+
+ template<typename _Tp>
+ struct __promote<_Tp, false>
+ { };
+
+ template<>
+ struct __promote<long double>
+ { typedef long double __type; };
+
+ template<>
+ struct __promote<double>
+ { typedef double __type; };
+
+ template<>
+ struct __promote<float>
+ { typedef float __type; };
+# 225 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/type_traits.h" 3
+ template<typename... _Tp>
+ using __promoted_t = decltype((typename __promote<_Tp>::__type(0) + ...));
+
+
+
+ template<typename _Tp, typename _Up>
+ using __promote_2 = __promote<__promoted_t<_Tp, _Up>>;
+
+ template<typename _Tp, typename _Up, typename _Vp>
+ using __promote_3 = __promote<__promoted_t<_Tp, _Up, _Vp>>;
+
+ template<typename _Tp, typename _Up, typename _Vp, typename _Wp>
+ using __promote_4 = __promote<__promoted_t<_Tp, _Up, _Vp, _Wp>>;
+# 270 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/type_traits.h" 3
+}
+}
+# 36 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 2 3
+
+namespace __gnu_cxx __attribute__ ((__visibility__ ("default")))
+{
+# 50 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 3
+ template<typename _Tp>
+ struct __is_integer_nonstrict
+ : public std::__is_integer<_Tp>
+ {
+ using std::__is_integer<_Tp>::__value;
+
+
+ enum { __width = __value ? sizeof(_Tp) * 8 : 0 };
+ };
+
+ template<typename _Value>
+ struct __numeric_traits_integer
+ {
+
+ static_assert(__is_integer_nonstrict<_Value>::__value,
+ "invalid specialization");
+
+
+
+
+ static const bool __is_signed = (_Value)(-1) < 0;
+ static const int __digits
+ = __is_integer_nonstrict<_Value>::__width - __is_signed;
+
+
+ static const _Value __max = __is_signed
+ ? (((((_Value)1 << (__digits - 1)) - 1) << 1) + 1)
+ : ~(_Value)0;
+ static const _Value __min = __is_signed ? -__max - 1 : (_Value)0;
+ };
+
+ template<typename _Value>
+ const _Value __numeric_traits_integer<_Value>::__min;
+
+ template<typename _Value>
+ const _Value __numeric_traits_integer<_Value>::__max;
+
+ template<typename _Value>
+ const bool __numeric_traits_integer<_Value>::__is_signed;
+
+ template<typename _Value>
+ const int __numeric_traits_integer<_Value>::__digits;
+# 130 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 3
+ __extension__ template<> struct __is_integer_nonstrict<__int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; }; __extension__ template<> struct __is_integer_nonstrict<unsigned __int128> { enum { __value = 1 }; typedef std::__true_type __type; enum { __width = 128 }; };
+
+
+
+
+
+
+ template<typename _Tp>
+ using __int_traits = __numeric_traits_integer<_Tp>;
+# 157 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 3
+ template<typename _Value>
+ struct __numeric_traits_floating
+ {
+
+ static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 64) * 643L / 2136);
+
+
+ static const bool __is_signed = true;
+ static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 18);
+ static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 4932);
+ };
+
+ template<typename _Value>
+ const int __numeric_traits_floating<_Value>::__max_digits10;
+
+ template<typename _Value>
+ const bool __numeric_traits_floating<_Value>::__is_signed;
+
+ template<typename _Value>
+ const int __numeric_traits_floating<_Value>::__digits10;
+
+ template<typename _Value>
+ const int __numeric_traits_floating<_Value>::__max_exponent10;
+
+
+
+
+
+
+ template<typename _Value>
+ struct __numeric_traits
+ : public __numeric_traits_integer<_Value>
+ { };
+
+ template<>
+ struct __numeric_traits<float>
+ : public __numeric_traits_floating<float>
+ { };
+
+ template<>
+ struct __numeric_traits<double>
+ : public __numeric_traits_floating<double>
+ { };
+
+ template<>
+ struct __numeric_traits<long double>
+ : public __numeric_traits_floating<long double>
+ { };
+# 239 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/ext/numeric_traits.h" 3
+}
+# 80 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 2 3
+# 96 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 3
+# 1 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 1 3
+# 48 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/bits/version.h" 3
+# 97 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 2 3
+
+namespace std __attribute__ ((__visibility__ ("default")))
+{
+
+
+
+
+ template <typename _Tp, typename _Up = _Tp>
+ constexpr
+ inline _Tp
+ exchange(_Tp& __obj, _Up&& __new_val)
+ noexcept(__and_<is_nothrow_move_constructible<_Tp>,
+ is_nothrow_assignable<_Tp&, _Up>>::value)
+ { return std::__exchange(__obj, std::forward<_Up>(__new_val)); }
+
+
+
+ template<typename _Tp>
+ [[nodiscard]]
+ constexpr add_const_t<_Tp>&
+ as_const(_Tp& __t) noexcept
+ { return __t; }
+
+ template<typename _Tp>
+ void as_const(const _Tp&&) = delete;
+
+
+
+ template<typename _Tp, typename _Up>
+ constexpr bool
+ cmp_equal(_Tp __t, _Up __u) noexcept
+ {
+ static_assert(__is_standard_integer<_Tp>::value);
+ static_assert(__is_standard_integer<_Up>::value);
+
+ if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+ return __t == __u;
+ else if constexpr (is_signed_v<_Tp>)
+ return __t >= 0 && make_unsigned_t<_Tp>(__t) == __u;
+ else
+ return __u >= 0 && __t == make_unsigned_t<_Up>(__u);
+ }
+
+ template<typename _Tp, typename _Up>
+ constexpr bool
+ cmp_not_equal(_Tp __t, _Up __u) noexcept
+ { return !std::cmp_equal(__t, __u); }
+
+ template<typename _Tp, typename _Up>
+ constexpr bool
+ cmp_less(_Tp __t, _Up __u) noexcept
+ {
+ static_assert(__is_standard_integer<_Tp>::value);
+ static_assert(__is_standard_integer<_Up>::value);
+
+ if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
+ return __t < __u;
+ else if constexpr (is_signed_v<_Tp>)
+ return __t < 0 || make_unsigned_t<_Tp>(__t) < __u;
+ else
+ return __u >= 0 && __t < make_unsigned_t<_Up>(__u);
+ }
+
+ template<typename _Tp, typename _Up>
+ constexpr bool
+ cmp_greater(_Tp __t, _Up __u) noexcept
+ { return std::cmp_less(__u, __t); }
+
+ template<typename _Tp, typename _Up>
+ constexpr bool
+ cmp_less_equal(_Tp __t, _Up __u) noexcept
+ { return !std::cmp_less(__u, __t); }
+
+ template<typename _Tp, typename _Up>
+ constexpr bool
+ cmp_greater_equal(_Tp __t, _Up __u) noexcept
+ { return !std::cmp_less(__t, __u); }
+
+ template<typename _Res, typename _Tp>
+ constexpr bool
+ in_range(_Tp __t) noexcept
+ {
+ static_assert(__is_standard_integer<_Res>::value);
+ static_assert(__is_standard_integer<_Tp>::value);
+ using __gnu_cxx::__int_traits;
+
+ if constexpr (is_signed_v<_Tp> == is_signed_v<_Res>)
+ return __int_traits<_Res>::__min <= __t
+ && __t <= __int_traits<_Res>::__max;
+ else if constexpr (is_signed_v<_Tp>)
+ return __t >= 0
+ && make_unsigned_t<_Tp>(__t) <= __int_traits<_Res>::__max;
+ else
+ return __t <= make_unsigned_t<_Res>(__int_traits<_Res>::__max);
+ }
+# 231 "/usr/lib64/gcc/x86_64-pc-linux-gnu/14.2.1/../../../../include/c++/14.2.1/utility" 3
+}
+# 4 "includes.hpp" 2
+
+
+export module Foo;
+
+template<typename T, typename ... Args>
+concept EnableCtor = sizeof...(Args) != 1 || (sizeof...(Args) == 1 && !std::same_as<T, typename std::remove_cvref<Args...>::type>);
+
+export {
+template<class T, bool A = false>
+class Foo {
+ public:
+ template<class... Args>
+ requires (EnableCtor<Foo<T, A>, Args...>)
+ explicit (sizeof...(Args) == 1) Foo(Args&&... args);
+
+ template<class... Args>
+ auto init(Args&&... args) -> void;
+};
+}
+
+template<class T, bool A>
+template<class... Args>
+ requires (EnableCtor<Foo<T, A>, Args...>)
+inline Foo<T, A>::Foo(Args&&... args) {
+ init(std::forward<Args>(args)...);
+}
+
+template<class T, bool A>
+template<class... Args>
+inline auto Foo<T, A>::init(Args&&... args) -> void {
+ auto _ = T { std::forward<Args>(args)... };
+}
+
+//--- Bar.cppm
+export module Bar;
+import Foo;
+
+struct Bar {};
+
+void a() {
+ auto foo = Foo<Bar>{};
+}
More information about the cfe-commits
mailing list