Commit dfabf1586fa2fcd9350e204fa138f44f952acbfd | zig

lib/libcxx/include/__algorithm/all_of.h+11-5

 @@ -10,24 +10,28 @@
 #ifndef _LIBCPP___ALGORITHM_ALL_OF_H
 #define _LIBCPP___ALGORITHM_ALL_OF_H
+#include <__algorithm/any_of.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__type_traits/invoke.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Iter, class _Sent, class _Proj, class _Pred>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
 __all_of(_Iter __first, _Sent __last, _Pred& __pred, _Proj& __proj) {
-  for (; __first != __last; ++__first) {
+  using _Ref          = decltype(std::__invoke(__proj, *__first));
-    if (!std::__invoke(__pred, std::__invoke(__proj, *__first)))
+  auto __negated_pred = [&__pred](_Ref __arg) -> bool { return !std::__invoke(__pred, std::forward<_Ref>(__arg)); };
-      return false;
+  return !std::__any_of(std::move(__first), std::move(__last), __negated_pred, __proj);
-  }
-  return true;
 }
 template <class _InputIterator, class _Predicate>
 @@ -39,4 +43,6 @@ all_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
 _LIBCPP_END_NAMESPACE_STD
+_LIBCPP_POP_MACROS
 #endif // _LIBCPP___ALGORITHM_ALL_OF_H

lib/libcxx/include/__algorithm/comp.h+4

...	@@ -11,6 +11,7 @@	...	@@ -11,6 +11,7 @@
11		11
12	#include <__config>	12	#include <__config>
13	#include <__type_traits/desugars_to.h>	13	#include <__type_traits/desugars_to.h>
		14	#include <__type_traits/is_generic_transparent_comparator.h>
14	#include <__type_traits/is_integral.h>	15	#include <__type_traits/is_integral.h>
15		16
16	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -48,6 +49,9 @@ inline const bool __desugars_to_v<__less_tag, __less<>, _Tp, _Tp> = true;	...	@@ -48,6 +49,9 @@ inline const bool __desugars_to_v<__less_tag, __less<>, _Tp, _Tp> = true;
48	template <class _Tp>	49	template <class _Tp>
49	inline const bool __desugars_to_v<__totally_ordered_less_tag, __less<>, _Tp, _Tp> = is_integral<_Tp>::value;	50	inline const bool __desugars_to_v<__totally_ordered_less_tag, __less<>, _Tp, _Tp> = is_integral<_Tp>::value;
50		51
		52	template <>
		53	inline const bool __is_generic_transparent_comparator_v<__less<> > = true;
		54
51	_LIBCPP_END_NAMESPACE_STD	55	_LIBCPP_END_NAMESPACE_STD
52		56
53	#endif // _LIBCPP___ALGORITHM_COMP_H	57	#endif // _LIBCPP___ALGORITHM_COMP_H

lib/libcxx/include/__algorithm/copy.h+28-147

...	@@ -12,11 +12,10 @@	...	@@ -12,11 +12,10 @@
12	#include <__algorithm/copy_move_common.h>	12	#include <__algorithm/copy_move_common.h>
13	#include <__algorithm/for_each_segment.h>	13	#include <__algorithm/for_each_segment.h>
14	#include <__algorithm/min.h>	14	#include <__algorithm/min.h>
		15	#include <__algorithm/specialized_algorithms.h>
15	#include <__config>	16	#include <__config>
16	#include <__fwd/bit_reference.h>
17	#include <__iterator/iterator_traits.h>	17	#include <__iterator/iterator_traits.h>
18	#include <__iterator/segmented_iterator.h>	18	#include <__iterator/segmented_iterator.h>
19	#include <__memory/pointer_traits.h>
20	#include <__type_traits/common_type.h>	19	#include <__type_traits/common_type.h>
21	#include <__type_traits/enable_if.h>	20	#include <__type_traits/enable_if.h>
22	#include <__utility/move.h>	21	#include <__utility/move.h>
...	@@ -38,124 +37,14 @@ copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result);	...	@@ -38,124 +37,14 @@ copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result);
38	template <class _InIter, class _Sent, class _OutIter>	37	template <class _InIter, class _Sent, class _OutIter>
39	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter> __copy(_InIter, _Sent, _OutIter);	38	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter> __copy(_InIter, _Sent, _OutIter);
40		39
41	template <class _Cp, bool _IsConst>
42	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> __copy_aligned(
43	__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
44	using _In = __bit_iterator<_Cp, _IsConst>;
45	using difference_type = typename _In::difference_type;
46	using __storage_type = typename _In::__storage_type;
47
48	const int __bits_per_word = _In::__bits_per_word;
49	difference_type __n = __last - __first;
50	if (__n > 0) {
51	// do first word
52	if (__first.__ctz_ != 0) {
53	unsigned __clz = __bits_per_word - __first.__ctz_;
54	difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
55	__n -= __dn;
56	__storage_type __m = std::__middle_mask<__storage_type>(__clz - __dn, __first.__ctz_);
57	__storage_type __b = *__first.__seg_ & __m;
58	*__result.__seg_ &= ~__m;
59	*__result.__seg_ \|= __b;
60	__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
61	__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
62	++__first.__seg_;
63	// __first.__ctz_ = 0;
64	}
65	// __first.__ctz_ == 0;
66	// do middle words
67	__storage_type __nw = __n / __bits_per_word;
68	std::copy(std::__to_address(__first.__seg_),
69	std::__to_address(__first.__seg_ + __nw),
70	std::__to_address(__result.__seg_));
71	__n -= __nw * __bits_per_word;
72	__result.__seg_ += __nw;
73	// do last word
74	if (__n > 0) {
75	__first.__seg_ += __nw;
76	__storage_type __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
77	__storage_type __b = *__first.__seg_ & __m;
78	*__result.__seg_ &= ~__m;
79	*__result.__seg_ \|= __b;
80	__result.__ctz_ = static_cast<unsigned>(__n);
81	}
82	}
83	return __result;
84	}
85
86	template <class _Cp, bool _IsConst>
87	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __bit_iterator<_Cp, false> __copy_unaligned(
88	__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, __bit_iterator<_Cp, false> __result) {
89	using _In = __bit_iterator<_Cp, _IsConst>;
90	using difference_type = typename _In::difference_type;
91	using __storage_type = typename _In::__storage_type;
92
93	const int __bits_per_word = _In::__bits_per_word;
94	difference_type __n = __last - __first;
95	if (__n > 0) {
96	// do first word
97	if (__first.__ctz_ != 0) {
98	unsigned __clz_f = __bits_per_word - __first.__ctz_;
99	difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
100	__n -= __dn;
101	__storage_type __m = std::__middle_mask<__storage_type>(__clz_f - __dn, __first.__ctz_);
102	__storage_type __b = *__first.__seg_ & __m;
103	unsigned __clz_r = __bits_per_word - __result.__ctz_;
104	__storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
105	__m = std::__middle_mask<__storage_type>(__clz_r - __ddn, __result.__ctz_);
106	*__result.__seg_ &= ~__m;
107	if (__result.__ctz_ > __first.__ctz_)
108	*__result.__seg_ \|= __b << (__result.__ctz_ - __first.__ctz_);
109	else
110	*__result.__seg_ \|= __b >> (__first.__ctz_ - __result.__ctz_);
111	__result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
112	__result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
113	__dn -= __ddn;
114	if (__dn > 0) {
115	__m = std::__trailing_mask<__storage_type>(__bits_per_word - __dn);
116	*__result.__seg_ &= ~__m;
117	*__result.__seg_ \|= __b >> (__first.__ctz_ + __ddn);
118	__result.__ctz_ = static_cast<unsigned>(__dn);
119	}
120	++__first.__seg_;
121	// __first.__ctz_ = 0;
122	}
123	// __first.__ctz_ == 0;
124	// do middle words
125	unsigned __clz_r = __bits_per_word - __result.__ctz_;
126	__storage_type __m = std::__leading_mask<__storage_type>(__result.__ctz_);
127	for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
128	__storage_type __b = *__first.__seg_;
129	*__result.__seg_ &= ~__m;
130	*__result.__seg_ \|= __b << __result.__ctz_;
131	++__result.__seg_;
132	*__result.__seg_ &= __m;
133	*__result.__seg_ \|= __b >> __clz_r;
134	}
135	// do last word
136	if (__n > 0) {
137	__m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
138	__storage_type __b = *__first.__seg_ & __m;
139	__storage_type __dn = std::min(__n, static_cast<difference_type>(__clz_r));
140	__m = std::__middle_mask<__storage_type>(__clz_r - __dn, __result.__ctz_);
141	*__result.__seg_ &= ~__m;
142	*__result.__seg_ \|= __b << __result.__ctz_;
143	__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
144	__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
145	__n -= __dn;
146	if (__n > 0) {
147	__m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
148	*__result.__seg_ &= ~__m;
149	*__result.__seg_ \|= __b >> __dn;
150	__result.__ctz_ = static_cast<unsigned>(__n);
151	}
152	}
153	}
154	return __result;
155	}
156
157	struct __copy_impl {	40	struct __copy_impl {
158	template <class _InIter, class _Sent, class _OutIter>	41	template <class _InIter,
		42	class _Sent,
		43	class _OutIter,
		44	__enable_if_t<!__specialized_algorithm<_Algorithm::__copy,
		45	__iterator_pair<_InIter, _Sent>,
		46	__single_iterator<_OutIter> >::__has_algorithm,
		47	int> = 0>
159	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>	48	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
160	operator()(_InIter __first, _Sent __last, _OutIter __result) const {	49	operator()(_InIter __first, _Sent __last, _OutIter __result) const {
161	while (__first != __last) {	50	while (__first != __last) {
...	@@ -167,37 +56,39 @@ struct __copy_impl {	...	@@ -167,37 +56,39 @@ struct __copy_impl {
167	return std::make_pair(std::move(__first), std::move(__result));	56	return std::make_pair(std::move(__first), std::move(__result));
168	}	57	}
169		58
170	template <class _InIter, class _OutIter>	59	template <class _InIter,
171	struct _CopySegment {	60	class _Sent,
172	using _Traits _LIBCPP_NODEBUG = __segmented_iterator_traits<_InIter>;	61	class _OutIter,
173		62	__enable_if_t<__specialized_algorithm<_Algorithm::__copy,
174	_OutIter& __result_;	63	__iterator_pair<_InIter, _Sent>,
175		64	__single_iterator<_OutIter> >::__has_algorithm,
176	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit _CopySegment(_OutIter& __result)	65	int> = 0>
177	: __result_(__result) {}	66	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 static pair<_InIter, _OutIter>
178		67	operator()(_InIter __first, _Sent __last, _OutIter __result) {
179	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void	68	return __specialized_algorithm<_Algorithm::__copy, __iterator_pair<_InIter, _Sent>, __single_iterator<_OutIter> >()(
180	operator()(typename _Traits::__local_iterator __lfirst, typename _Traits::__local_iterator __llast) {	69	std::move(__first), std::move(__last), std::move(__result));
181	__result_ = std::__copy(__lfirst, __llast, std::move(__result_)).second;	70	}
182	}
183	};
184		71
185	template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator<_InIter>::value, int> = 0>	72	template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator_v<_InIter>, int> = 0>
186	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>	73	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
187	operator()(_InIter __first, _InIter __last, _OutIter __result) const {	74	operator()(_InIter __first, _InIter __last, _OutIter __result) const {
188	std::__for_each_segment(__first, __last, _CopySegment<_InIter, _OutIter>(__result));	75	using __local_iterator = typename __segmented_iterator_traits<_InIter>::__local_iterator;
		76	std::__for_each_segment(__first, __last, [&__result](__local_iterator __lfirst, __local_iterator __llast) {
		77	__result = std::__copy(std::move(__lfirst), std::move(__llast), std::move(__result)).second;
		78	});
189	return std::make_pair(__last, std::move(__result));	79	return std::make_pair(__last, std::move(__result));
190	}	80	}
191		81
192	template <class _InIter,	82	template <class _InIter,
193	class _OutIter,	83	class _OutIter,
194	__enable_if_t<__has_random_access_iterator_category<_InIter>::value &&	84	__enable_if_t<__has_random_access_iterator_category<_InIter>::value &&
195	!__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,	85	!__is_segmented_iterator_v<_InIter> && __is_segmented_iterator_v<_OutIter>,
196	int> = 0>	86	int> = 0>
197	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>	87	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
198	operator()(_InIter __first, _InIter __last, _OutIter __result) const {	88	operator()(_InIter __first, _InIter __last, _OutIter __result) const {
199	using _Traits = __segmented_iterator_traits<_OutIter>;	89	using _Traits = __segmented_iterator_traits<_OutIter>;
200	using _DiffT = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;	90	using _DiffT =
		91	typename common_type<__iterator_difference_type<_InIter>, __iterator_difference_type<_OutIter> >::type;
201		92
202	if (__first == __last)	93	if (__first == __last)
203	return std::make_pair(std::move(__first), std::move(__result));	94	return std::make_pair(std::move(__first), std::move(__result));
...	@@ -217,16 +108,6 @@ struct __copy_impl {	...	@@ -217,16 +108,6 @@ struct __copy_impl {
217	}	108	}
218	}	109	}
219		110
220	template <class _Cp, bool _IsConst>
221	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, false> >
222	operator()(__bit_iterator<_Cp, _IsConst> __first,
223	__bit_iterator<_Cp, _IsConst> __last,
224	__bit_iterator<_Cp, false> __result) const {
225	if (__first.__ctz_ == __result.__ctz_)
226	return std::make_pair(__last, std::__copy_aligned(__first, __last, __result));
227	return std::make_pair(__last, std::__copy_unaligned(__first, __last, __result));
228	}
229
230	// At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.	111	// At this point, the iterators have been unwrapped so any `contiguous_iterator` has been unwrapped to a pointer.
231	template <class _In, class _Out, __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>	112	template <class _In, class _Out, __enable_if_t<__can_lower_copy_assignment_to_memmove<_In, _Out>::value, int> = 0>
232	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In, _Out>	113	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_In, _Out>

lib/libcxx/include/__algorithm/copy_backward.h+9-24

 @@ -11,6 +11,7 @@
 #include <__algorithm/copy_move_common.h>
 #include <__algorithm/copy_n.h>
+#include <__algorithm/for_each_segment.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/min.h>
 #include <__config>
 @@ -170,37 +171,20 @@ struct __copy_backward_impl {
     return std::make_pair(std::move(__original_last_iter), std::move(__result));
   }
-  template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator<_InIter>::value, int> = 0>
+  template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator_v<_InIter>, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __last, _OutIter __result) const {
-    using _Traits = __segmented_iterator_traits<_InIter>;
+    using __local_iterator = typename __segmented_iterator_traits<_InIter>::__local_iterator;
-    auto __sfirst = _Traits::__segment(__first);
+    std::__for_each_segment_backward(__first, __last, [&__result](__local_iterator __lfirst, __local_iterator __llast) {
-    auto __slast  = _Traits::__segment(__last);
+      __result = std::__copy_backward<_AlgPolicy>(std::move(__lfirst), std::move(__llast), std::move(__result)).second;
-    if (__sfirst == __slast) {
+    });
-      auto __iters =
-          std::__copy_backward<_AlgPolicy>(_Traits::__local(__first), _Traits::__local(__last), std::move(__result));
-      return std::make_pair(__last, __iters.second);
-    }
-    __result =
-        std::__copy_backward<_AlgPolicy>(_Traits::__begin(__slast), _Traits::__local(__last), std::move(__result))
-            .second;
-    --__slast;
-    while (__sfirst != __slast) {
-      __result =
-          std::__copy_backward<_AlgPolicy>(_Traits::__begin(__slast), _Traits::__end(__slast), std::move(__result))
-              .second;
-      --__slast;
-    }
-    __result = std::__copy_backward<_AlgPolicy>(_Traits::__local(__first), _Traits::__end(__slast), std::move(__result))
-                   .second;
     return std::make_pair(__last, std::move(__result));
   }
   template <class _InIter,
             class _OutIter,
             __enable_if_t<__has_random_access_iterator_category<_InIter>::value &&
-                              !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
+                              !__is_segmented_iterator_v<_InIter> && __is_segmented_iterator_v<_OutIter>,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __last, _OutIter __result) const {
 @@ -214,7 +198,8 @@ struct __copy_backward_impl {
     auto __local_last = _Traits::__local(__result);
     while (true) {
-      using _DiffT = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;
+      using _DiffT =
+          typename common_type<__iterator_difference_type<_InIter>, __iterator_difference_type<_OutIter> >::type;
       auto __local_first = _Traits::__begin(__segment_iterator);
       auto __size        = std::min<_DiffT>(__local_last - __local_first, __last - __first);

lib/libcxx/include/__algorithm/copy_n.h+50-16

 @@ -10,31 +10,63 @@
 #define _LIBCPP___ALGORITHM_COPY_N_H
 #include <__algorithm/copy.h>
+#include <__algorithm/iterator_operations.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
 #include <__type_traits/enable_if.h>
 #include <__utility/convert_to_integral.h>
+#include <__utility/move.h>
+#include <__utility/pair.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 _LIBCPP_BEGIN_NAMESPACE_STD
+template <class _AlgPolicy,
+          class _InIter,
+          class _OutIter,
+          __enable_if_t<__has_random_access_iterator_category<_InIter>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InIter, _OutIter>
+__copy_n(_InIter __first, typename _IterOps<_AlgPolicy>::template __difference_type<_InIter> __n, _OutIter __result) {
+  return std::__copy(__first, __first + __n, std::move(__result));
+}
+template <class _AlgPolicy,
+          class _InIter,
+          class _OutIter,
+          __enable_if_t<!__has_random_access_iterator_category<_InIter>::value, int> = 0>
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InIter, _OutIter>
+__copy_n(_InIter __first, typename _IterOps<_AlgPolicy>::template __difference_type<_InIter> __n, _OutIter __result) {
+  while (__n != 0) {
+    *__result = *__first;
+    ++__first;
+    ++__result;
+    --__n;
+  }
+  return std::make_pair(std::move(__first), std::move(__result));
+}
+// The InputIterator case is handled specially here because it's been written in a way to avoid incrementing __first
+// if not absolutely required. This was done to allow its use with istream_iterator and we want to avoid breaking
+// people, at least currently.
+// See https://github.com/llvm/llvm-project/commit/99847d2bf132854fffa019bab19818768102ccad
 template <class _InputIterator,
           class _Size,
           class _OutputIterator,
-          __enable_if_t<__has_input_iterator_category<_InputIterator>::value &&
+          __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
-                            !__has_random_access_iterator_category<_InputIterator>::value,
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
-                        int> = 0>
+copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) {
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+  using _IntegralSize       = decltype(std::__convert_to_integral(__n));
-copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) {
+  _IntegralSize __converted = __n;
-  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
+  if (__converted > 0) {
-  _IntegralSize __n = __orig_n;
-  if (__n > 0) {
     *__result = *__first;
     ++__result;
-    for (--__n; __n > 0; --__n) {
+    for (--__converted; __converted > 0; --__converted) {
       ++__first;
       *__result = *__first;
       ++__result;
 @@ -46,15 +78,17 @@ copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) {
 template <class _InputIterator,
           class _Size,
           class _OutputIterator,
-          __enable_if_t<__has_random_access_iterator_category<_InputIterator>::value, int> = 0>
+          __enable_if_t<!__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
-copy_n(_InputIterator __first, _Size __orig_n, _OutputIterator __result) {
+copy_n(_InputIterator __first, _Size __n, _OutputIterator __result) {
-  typedef typename iterator_traits<_InputIterator>::difference_type difference_type;
+  using _IntegralSize       = decltype(std::__convert_to_integral(__n));
-  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
+  _IntegralSize __converted = __n;
-  _IntegralSize __n = __orig_n;
+  return std::__copy_n<_ClassicAlgPolicy>(__first, __iterator_difference_type<_InputIterator>(__converted), __result)
-  return std::copy(__first, __first + difference_type(__n), __result);
+      .second;
 }
 _LIBCPP_END_NAMESPACE_STD
+_LIBCPP_POP_MACROS
 #endif // _LIBCPP___ALGORITHM_COPY_N_H

lib/libcxx/include/__algorithm/count.h+2-2

...	@@ -72,7 +72,7 @@ __count_bool(__bit_iterator<_Cp, _IsConst> __first, typename __size_difference_t	...	@@ -72,7 +72,7 @@ __count_bool(__bit_iterator<_Cp, _IsConst> __first, typename __size_difference_t
72	}	72	}
73		73
74	template <class, class _Cp, bool _IsConst, class _Tp, class _Proj, __enable_if_t<__is_identity<_Proj>::value, int> = 0>	74	template <class, class _Cp, bool _IsConst, class _Tp, class _Proj, __enable_if_t<__is_identity<_Proj>::value, int> = 0>
75	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __iter_diff_t<__bit_iterator<_Cp, _IsConst> >	75	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __iterator_difference_type<__bit_iterator<_Cp, _IsConst> >
76	__count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value, _Proj&) {	76	__count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __last, const _Tp& __value, _Proj&) {
77	if (__value)	77	if (__value)
78	return std::__count_bool<true>(	78	return std::__count_bool<true>(
...	@@ -82,7 +82,7 @@ __count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __l	...	@@ -82,7 +82,7 @@ __count(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __l
82	}	82	}
83		83
84	template <class _InputIterator, class _Tp>	84	template <class _InputIterator, class _Tp>
85	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __iter_diff_t<_InputIterator>	85	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __iterator_difference_type<_InputIterator>
86	count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {	86	count(_InputIterator __first, _InputIterator __last, const _Tp& __value) {
87	__identity __proj;	87	__identity __proj;
88	return std::__count<_ClassicAlgPolicy>(__first, __last, __value, __proj);	88	return std::__count<_ClassicAlgPolicy>(__first, __last, __value, __proj);

lib/libcxx/include/__algorithm/equal.h+43-55

 @@ -160,22 +160,28 @@ template <class _Cp,
           bool _IsConst1,
           bool _IsConst2,
           class _BinaryPredicate,
-          __enable_if_t<__desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>, int> = 0>
+          class _Proj1,
+          class _Proj2,
+          __enable_if_t<__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
+                            __desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>,
+                        int> = 0>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_iter_impl(
     __bit_iterator<_Cp, _IsConst1> __first1,
     __bit_iterator<_Cp, _IsConst1> __last1,
     __bit_iterator<_Cp, _IsConst2> __first2,
-    _BinaryPredicate) {
+    _BinaryPredicate,
+    _Proj1&,
+    _Proj2&) {
   if (__first1.__ctz_ == __first2.__ctz_)
     return std::__equal_aligned(__first1, __last1, __first2);
   return std::__equal_unaligned(__first1, __last1, __first2);
 }
-template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
+template <class _InIter1, class _Sent1, class _InIter2, class _Pred, class _Proj1, class _Proj2>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_iter_impl(
-    _InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate& __pred) {
+    _InIter1 __first1, _Sent1 __last1, _InIter2 __first2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {
   for (; __first1 != __last1; ++__first1, (void)++__first2)
-    if (!__pred(*__first1, *__first2))
+    if (!std::__invoke(__pred, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
       return false;
   return true;
 }
 @@ -183,19 +189,23 @@ template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
 template <class _Tp,
           class _Up,
           class _BinaryPredicate,
-          __enable_if_t<__desugars_to_v<__equal_tag, _BinaryPredicate, _Tp, _Up> && !is_volatile<_Tp>::value &&
+          class _Proj1,
-                            !is_volatile<_Up>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
+          class _Proj2,
+          __enable_if_t<__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
+                            __desugars_to_v<__equal_tag, _BinaryPredicate, _Tp, _Up> && !is_volatile<_Tp>::value &&
+                            !is_volatile<_Up>::value && __is_trivially_equality_comparable_v<_Tp, _Up>,
                         int> = 0>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__equal_iter_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _BinaryPredicate&) {
+__equal_iter_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _BinaryPredicate&, _Proj1&, _Proj2&) {
   return std::__constexpr_memcmp_equal(__first1, __first2, __element_count(__last1 - __first1));
 }
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _BinaryPredicate __pred) {
+  __identity __proj;
   return std::__equal_iter_impl(
-      std::__unwrap_iter(__first1), std::__unwrap_iter(__last1), std::__unwrap_iter(__first2), __pred);
+      std::__unwrap_iter(__first1), std::__unwrap_iter(__last1), std::__unwrap_iter(__first2), __pred, __proj, __proj);
 }
 template <class _InputIterator1, class _InputIterator2>
 @@ -206,52 +216,28 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first
 #if _LIBCPP_STD_VER >= 14
-template <class _Iter1, class _Sent1, class _Iter2, class _Sent2, class _Pred, class _Proj1, class _Proj2>
+template <bool __known_equal_length,
-[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
+          class _Iter1,
-    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __comp, _Proj1& __proj1, _Proj2& __proj2) {
+          class _Sent1,
-  while (__first1 != __last1 && __first2 != __last2) {
+          class _Iter2,
-    if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
+          class _Sent2,
-      return false;
-    ++__first1;
-    ++__first2;
-  }
-  return __first1 == __last1 && __first2 == __last2;
-}
-template <class _Tp,
-          class _Up,
-          class _Pred,
-          class _Proj1,
-          class _Proj2,
-          __enable_if_t<__desugars_to_v<__equal_tag, _Pred, _Tp, _Up> && __is_identity<_Proj1>::value &&
-                            __is_identity<_Proj2>::value && !is_volatile<_Tp>::value && !is_volatile<_Up>::value &&
-                            __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
-                        int> = 0>
-[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
-__equal_impl(_Tp* __first1, _Tp* __last1, _Up* __first2, _Up*, _Pred&, _Proj1&, _Proj2&) {
-  return std::__constexpr_memcmp_equal(__first1, __first2, __element_count(__last1 - __first1));
-}
-template <class _Cp,
-          bool _IsConst1,
-          bool _IsConst2,
           class _Pred,
           class _Proj1,
-          class _Proj2,
+          class _Proj2>
-          __enable_if_t<__desugars_to_v<__equal_tag, _Pred, bool, bool> && __is_identity<_Proj1>::value &&
-                            __is_identity<_Proj2>::value,
-                        int> = 0>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __equal_impl(
-    __bit_iterator<_Cp, _IsConst1> __first1,
+    _Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Sent2 __last2, _Pred& __comp, _Proj1& __proj1, _Proj2& __proj2) {
-    __bit_iterator<_Cp, _IsConst1> __last1,
+  if constexpr (__known_equal_length) {
-    __bit_iterator<_Cp, _IsConst2> __first2,
+    return std::__equal_iter_impl(
-    __bit_iterator<_Cp, _IsConst2>,
+        std::move(__first1), std::move(__last1), std::move(__first2), __comp, __proj1, __proj2);
-    _Pred&,
+  } else {
-    _Proj1&,
+    while (__first1 != __last1 && __first2 != __last2) {
-    _Proj2&) {
+      if (!std::__invoke(__comp, std::__invoke(__proj1, *__first1), std::__invoke(__proj2, *__first2)))
-  if (__first1.__ctz_ == __first2.__ctz_)
+        return false;
-    return std::__equal_aligned(__first1, __last1, __first2);
+      ++__first1;
-  return std::__equal_unaligned(__first1, __last1, __first2);
+      ++__first2;
+    }
+    return __first1 == __last1 && __first2 == __last2;
+  }
 }
 template <class _InputIterator1, class _InputIterator2, class _BinaryPredicate>
 @@ -261,13 +247,15 @@ equal(_InputIterator1 __first1,
       _InputIterator2 __first2,
       _InputIterator2 __last2,
       _BinaryPredicate __pred) {
-  if constexpr (__has_random_access_iterator_category<_InputIterator1>::value &&
+  static constexpr bool __both_random_access =
-                __has_random_access_iterator_category<_InputIterator2>::value) {
+      __has_random_access_iterator_category<_InputIterator1>::value &&
+      __has_random_access_iterator_category<_InputIterator2>::value;
+  if constexpr (__both_random_access) {
     if (std::distance(__first1, __last1) != std::distance(__first2, __last2))
       return false;
   }
   __identity __proj;
-  return std::__equal_impl(
+  return std::__equal_impl<__both_random_access>(
       std::__unwrap_iter(__first1),
       std::__unwrap_iter(__last1),
       std::__unwrap_iter(__first2),

lib/libcxx/include/__algorithm/fill.h+26-8

 @@ -10,8 +10,12 @@
 #define _LIBCPP___ALGORITHM_FILL_H
 #include <__algorithm/fill_n.h>
+#include <__algorithm/for_each_segment.h>
 #include <__config>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/segmented_iterator.h>
+#include <__type_traits/enable_if.h>
+#include <__type_traits/is_same.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 @@ -21,23 +25,37 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // fill isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.
-template <class _ForwardIterator, class _Tp>
+template <class _ForwardIterator, class _Sentinel, class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _ForwardIterator
-__fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, forward_iterator_tag) {
+__fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __value) {
+#ifndef _LIBCPP_CXX03_LANG
+  if constexpr (is_same<_ForwardIterator, _Sentinel>::value && __is_segmented_iterator_v<_ForwardIterator>) {
+    using __local_iterator_t = typename __segmented_iterator_traits<_ForwardIterator>::__local_iterator;
+    std::__for_each_segment(__first, __last, [&](__local_iterator_t __lfirst, __local_iterator_t __llast) {
+      std::__fill(__lfirst, __llast, __value);
+    });
+    return __last;
+  }
+#endif
   for (; __first != __last; ++__first)
     *__first = __value;
+  return __first;
 }
-template <class _RandomAccessIterator, class _Tp>
+template <class _RandomAccessIterator,
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+          class _Tp,
-__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag) {
+          __enable_if_t<__has_random_access_iterator_category<_RandomAccessIterator>::value &&
-  std::fill_n(__first, __last - __first, __value);
+                            !__is_segmented_iterator_v<_RandomAccessIterator>,
+                        int> = 0>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator
+__fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value) {
+  return std::__fill_n(__first, __last - __first, __value);
 }
 template <class _ForwardIterator, class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
 fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
-  std::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
+  std::__fill(__first, __last, __value);
 }
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__algorithm/fill_n.h+32-46

...	@@ -9,11 +9,14 @@	...	@@ -9,11 +9,14 @@
9	#ifndef _LIBCPP___ALGORITHM_FILL_N_H	9	#ifndef _LIBCPP___ALGORITHM_FILL_N_H
10	#define _LIBCPP___ALGORITHM_FILL_N_H	10	#define _LIBCPP___ALGORITHM_FILL_N_H
11		11
12	#include <__algorithm/min.h>	12	#include <__algorithm/for_each_n_segment.h>
		13	#include <__algorithm/specialized_algorithms.h>
13	#include <__config>	14	#include <__config>
14	#include <__fwd/bit_reference.h>	15	#include <__iterator/iterator_traits.h>
15	#include <__memory/pointer_traits.h>	16	#include <__iterator/segmented_iterator.h>
		17	#include <__type_traits/enable_if.h>
16	#include <__utility/convert_to_integral.h>	18	#include <__utility/convert_to_integral.h>
		19	#include <__utility/move.h>
17		20
18	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
19	# pragma GCC system_header	22	# pragma GCC system_header
...	@@ -26,56 +29,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -26,56 +29,39 @@ _LIBCPP_BEGIN_NAMESPACE_STD
26		29
27	// fill_n isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.	30	// fill_n isn't specialized for std::memset, because the compiler already optimizes the loop to a call to std::memset.
28		31
29	template <class _OutputIterator, class _Size, class _Tp>	32	template <
30	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator	33	class _OutputIterator,
31	__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value);	34	class _Size,
32		35	class _Tp,
33	template <bool _FillVal, class _Cp>	36	__enable_if_t<!__specialized_algorithm<_Algorithm::__fill_n, __single_iterator<_OutputIterator> >::__has_algorithm,
34	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	37	int> = 0>
35	__fill_n_bool(__bit_iterator<_Cp, false> __first, typename __size_difference_type_traits<_Cp>::size_type __n) {
36	using _It = __bit_iterator<_Cp, false>;
37	using __storage_type = typename _It::__storage_type;
38
39	const int __bits_per_word = _It::__bits_per_word;
40	// do first partial word
41	if (__first.__ctz_ != 0) {
42	__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
43	__storage_type __dn = std::min(__clz_f, __n);
44	std::__fill_masked_range(std::__to_address(__first.__seg_), __clz_f - __dn, __first.__ctz_, _FillVal);
45	__n -= __dn;
46	++__first.__seg_;
47	}
48	// do middle whole words
49	__storage_type __nw = __n / __bits_per_word;
50	std::__fill_n(std::__to_address(__first.__seg_), __nw, _FillVal ? static_cast<__storage_type>(-1) : 0);
51	__n -= __nw * __bits_per_word;
52	// do last partial word
53	if (__n > 0) {
54	__first.__seg_ += __nw;
55	std::__fill_masked_range(std::__to_address(__first.__seg_), __bits_per_word - __n, 0u, _FillVal);
56	}
57	}
58
59	template <class _Cp, class _Size>
60	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator<_Cp, false>
61	__fill_n(__bit_iterator<_Cp, false> __first, _Size __n, const bool& __value) {
62	if (__n > 0) {
63	if (__value)
64	std::__fill_n_bool<true>(__first, __n);
65	else
66	std::__fill_n_bool<false>(__first, __n);
67	}
68	return __first + __n;
69	}
70
71	template <class _OutputIterator, class _Size, class _Tp>
72	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator	38	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
73	__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) {	39	__fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) {
		40	#ifndef _LIBCPP_CXX03_LANG
		41	if constexpr (__is_segmented_iterator_v<_OutputIterator>) {
		42	using __local_iterator = typename __segmented_iterator_traits<_OutputIterator>::__local_iterator;
		43	if constexpr (__has_random_access_iterator_category<__local_iterator>::value) {
		44	return std::__for_each_n_segment(__first, __n, [&](__local_iterator __lfirst, __local_iterator __llast) {
		45	std::__fill_n(__lfirst, __llast - __lfirst, __value);
		46	});
		47	}
		48	}
		49	#endif
74	for (; __n > 0; ++__first, (void)--__n)	50	for (; __n > 0; ++__first, (void)--__n)
75	*__first = __value;	51	*__first = __value;
76	return __first;	52	return __first;
77	}	53	}
78		54
		55	template <class _OutIter,
		56	class _Size,
		57	class _Tp,
		58	__enable_if_t<__specialized_algorithm<_Algorithm::__fill_n, __single_iterator<_OutIter> >::__has_algorithm,
		59	int> = 0>
		60	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutIter __fill_n(_OutIter __first, _Size __n, const _Tp& __value) {
		61	return __specialized_algorithm<_Algorithm::__fill_n, __single_iterator<_OutIter> >()(
		62	std::move(__first), __n, __value);
		63	}
		64
79	template <class _OutputIterator, class _Size, class _Tp>	65	template <class _OutputIterator, class _Size, class _Tp>
80	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator	66	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
81	fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) {	67	fill_n(_OutputIterator __first, _Size __n, const _Tp& __value) {

lib/libcxx/include/__algorithm/find.h+96-39

 @@ -12,16 +12,19 @@
 #include <__algorithm/find_segment_if.h>
 #include <__algorithm/min.h>
+#include <__algorithm/simd_utils.h>
 #include <__algorithm/unwrap_iter.h>
 #include <__bit/countr.h>
 #include <__bit/invert_if.h>
 #include <__config>
+#include <__cstddef/size_t.h>
 #include <__functional/identity.h>
 #include <__fwd/bit_reference.h>
 #include <__iterator/segmented_iterator.h>
 #include <__string/constexpr_c_functions.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/invoke.h>
+#include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_signed.h>
 @@ -44,46 +47,108 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // generic implementation
 template <class _Iter, class _Sent, class _Tp, class _Proj>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter
-__find(_Iter __first, _Sent __last, const _Tp& __value, _Proj& __proj) {
+__find_loop(_Iter __first, _Sent __last, const _Tp& __value, _Proj& __proj) {
   for (; __first != __last; ++__first)
     if (std::__invoke(__proj, *__first) == __value)
       break;
   return __first;
 }
-// trivially equality comparable implementations
+template <class _Iter, class _Sent, class _Tp, class _Proj>
-template <class _Tp,
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Iter
-          class _Up,
+__find(_Iter __first, _Sent __last, const _Tp& __value, _Proj& __proj) {
-          class _Proj,
+  return std::__find_loop(std::move(__first), std::move(__last), __value, __proj);
-          __enable_if_t<__is_identity<_Proj>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value &&
-                            sizeof(_Tp) == 1,
-                        int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __find(_Tp* __first, _Tp* __last, const _Up& __value, _Proj&) {
-  if (auto __ret = std::__constexpr_memchr(__first, __value, __last - __first))
-    return __ret;
-  return __last;
 }
-#if _LIBCPP_HAS_WIDE_CHARACTERS
+#if _LIBCPP_VECTORIZE_ALGORITHMS
+template <class _Tp, class _Up>
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __find_vectorized(_Tp* __first, _Tp* __last, _Up __value) {
+  if (!__libcpp_is_constant_evaluated()) {
+    constexpr size_t __unroll_count = 4;
+    constexpr size_t __vec_size     = __native_vector_size<_Tp>;
+    using __vec                     = __simd_vector<_Tp, __vec_size>;
+    auto __orig_first = __first;
+    auto __values = static_cast<__simd_vector<_Tp, __vec_size>>(__value); // broadcast the value
+    while (static_cast<size_t>(__last - __first) >= __unroll_count * __vec_size) [[__unlikely__]] {
+      __vec __lhs[__unroll_count];
+      for (size_t __i = 0; __i != __unroll_count; ++__i)
+        __lhs[__i] = std::__load_vector<__vec>(__first + __i * __vec_size);
+      for (size_t __i = 0; __i != __unroll_count; ++__i) {
+        if (auto __cmp_res = __lhs[__i] == __values; std::__any_of(__cmp_res)) {
+          auto __offset = __i * __vec_size + std::__find_first_set(__cmp_res);
+          return __first + __offset;
+        }
+      }
+      __first += __unroll_count * __vec_size;
+    }
+    // check the remaining 0-3 vectors
+    while (static_cast<size_t>(__last - __first) >= __vec_size) {
+      if (auto __cmp_res = std::__load_vector<__vec>(__first) == __values; std::__any_of(__cmp_res)) {
+        return __first + std::__find_first_set(__cmp_res);
+      }
+      __first += __vec_size;
+    }
+    if (__last - __first == 0)
+      return __first;
+    // Check if we can load elements in front of the current pointer. If that's the case load a vector at
+    // (last - vector_size) to check the remaining elements
+    if (static_cast<size_t>(__first - __orig_first) >= __vec_size) {
+      __first = __last - __vec_size;
+      return __first + std::__find_first_set(std::__load_vector<__vec>(__first) == __values);
+    }
+  }
+  __identity __proj;
+  return std::__find_loop(__first, __last, __value, __proj);
+}
+#endif
+#ifndef _LIBCPP_CXX03_LANG
+// trivially equality comparable implementations
 template <class _Tp,
           class _Up,
           class _Proj,
-          __enable_if_t<__is_identity<_Proj>::value && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value &&
+          __enable_if_t<__is_identity<_Proj>::value && __is_trivially_equality_comparable_v<_Tp, _Up>, int> = 0>
-                            sizeof(_Tp) == sizeof(wchar_t) && _LIBCPP_ALIGNOF(_Tp) >= _LIBCPP_ALIGNOF(wchar_t),
-                        int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __find(_Tp* __first, _Tp* __last, const _Up& __value, _Proj&) {
-  if (auto __ret = std::__constexpr_wmemchr(__first, __value, __last - __first))
+  if constexpr (sizeof(_Tp) == 1) {
-    return __ret;
+    if (auto __ret = std::__constexpr_memchr(__first, __value, __last - __first))
-  return __last;
+      return __ret;
+    return __last;
+  }
+#  if _LIBCPP_HAS_WIDE_CHARACTERS
+  else if constexpr (sizeof(_Tp) == sizeof(wchar_t) && _LIBCPP_ALIGNOF(_Tp) >= _LIBCPP_ALIGNOF(wchar_t)) {
+    if (auto __ret = std::__constexpr_wmemchr(__first, __value, __last - __first))
+      return __ret;
+    return __last;
+  }
+#  endif
+#  if _LIBCPP_VECTORIZE_ALGORITHMS
+  else if constexpr (is_integral<_Tp>::value) {
+    return std::__find_vectorized(__first, __last, __value);
+  }
+#  endif
+  else {
+    __identity __proj;
+    return std::__find_loop(__first, __last, __value, __proj);
+  }
 }
-#endif // _LIBCPP_HAS_WIDE_CHARACTERS
+#endif
 // TODO: This should also be possible to get right with different signedness
 // cast integral types to allow vectorization
 template <class _Tp,
           class _Up,
           class _Proj,
-          __enable_if_t<__is_identity<_Proj>::value && !__libcpp_is_trivially_equality_comparable<_Tp, _Up>::value &&
+          __enable_if_t<__is_identity<_Proj>::value && !__is_trivially_equality_comparable_v<_Tp, _Up> &&
                             is_integral<_Tp>::value && is_integral<_Up>::value &&
                             is_signed<_Tp>::value == is_signed<_Up>::value,
                         int> = 0>
 @@ -143,31 +208,23 @@ __find(__bit_iterator<_Cp, _IsConst> __first, __bit_iterator<_Cp, _IsConst> __la
 // segmented iterator implementation
-template <class>
-struct __find_segment;
 template <class _SegmentedIterator,
           class _Tp,
           class _Proj,
-          __enable_if_t<__is_segmented_iterator<_SegmentedIterator>::value, int> = 0>
+          __enable_if_t<__is_segmented_iterator_v<_SegmentedIterator>, int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator
 __find(_SegmentedIterator __first, _SegmentedIterator __last, const _Tp& __value, _Proj& __proj) {
-  return std::__find_segment_if(std::move(__first), std::move(__last), __find_segment<_Tp>(__value), __proj);
+  using __local_iterator = typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator;
+  return std::__find_segment_if(
+      std::move(__first),
+      std::move(__last),
+      [&__value](__local_iterator __lfirst, __local_iterator __llast, _Proj& __lproj) {
+        return std::__rewrap_iter(
+            __lfirst, std::__find(std::__unwrap_iter(__lfirst), std::__unwrap_iter(__llast), __value, __lproj));
+      },
+      __proj);
 }
-template <class _Tp>
-struct __find_segment {
-  const _Tp& __value_;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __find_segment(const _Tp& __value) : __value_(__value) {}
-  template <class _InputIterator, class _Proj>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _InputIterator
-  operator()(_InputIterator __first, _InputIterator __last, _Proj& __proj) const {
-    return std::__find(__first, __last, __value_, __proj);
-  }
-};
 // public API
 template <class _InputIterator, class _Tp>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator

lib/libcxx/include/__algorithm/find_end.h+105

...	@@ -76,6 +76,111 @@ _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1>	...	@@ -76,6 +76,111 @@ _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1>
76	}	76	}
77	}	77	}
78		78
		79	template <class _AlgPolicy,
		80	class _Pred,
		81	class _Iter1,
		82	class _Sent1,
		83	class _Iter2,
		84	class _Sent2,
		85	class _Proj1,
		86	class _Proj2>
		87	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter1, _Iter1> __find_end_impl(
		88	_Iter1 __first1,
		89	_Sent1 __sent1,
		90	_Iter2 __first2,
		91	_Sent2 __sent2,
		92	_Pred& __pred,
		93	_Proj1& __proj1,
		94	_Proj2& __proj2,
		95	bidirectional_iterator_tag,
		96	bidirectional_iterator_tag) {
		97	auto __last1 = _IterOps<_AlgPolicy>::next(__first1, __sent1);
		98	auto __last2 = _IterOps<_AlgPolicy>::next(__first2, __sent2);
		99	// modeled after search algorithm (in reverse)
		100	if (__first2 == __last2)
		101	return std::make_pair(__last1, __last1); // Everything matches an empty sequence
		102	_Iter1 __l1 = __last1;
		103	_Iter2 __l2 = __last2;
		104	--__l2;
		105	while (true) {
		106	// Find last element in sequence 1 that matches *(__last2-1), with a mininum of loop checks
		107	while (true) {
		108	if (__first1 == __l1) // return __last1 if no element matches *__first2
		109	return std::make_pair(__last1, __last1);
		110	if (std::__invoke(__pred, std::__invoke(__proj1, --__l1), std::__invoke(__proj2, __l2)))
		111	break;
		112	}
		113	// __l1 matches __l2, now match elements before here
		114	_Iter1 __match_last = __l1;
		115	_Iter1 __m1 = __l1;
		116	_Iter2 __m2 = __l2;
		117	while (true) {
		118	if (__m2 == __first2) // If pattern exhausted, __m1 is the answer (works for 1 element pattern)
		119	return std::make_pair(__m1, ++__match_last);
		120	if (__m1 == __first1) // Otherwise if source exhaused, pattern not found
		121	return std::make_pair(__last1, __last1);
		122
		123	// if there is a mismatch, restart with a new __l1
		124	if (!std::__invoke(__pred, std::__invoke(__proj1, --__m1), std::__invoke(__proj2, --__m2))) {
		125	break;
		126	} // else there is a match, check next elements
		127	}
		128	}
		129	}
		130
		131	template <class _AlgPolicy,
		132	class _Pred,
		133	class _Iter1,
		134	class _Sent1,
		135	class _Iter2,
		136	class _Sent2,
		137	class _Proj1,
		138	class _Proj2>
		139	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter1, _Iter1> __find_end_impl(
		140	_Iter1 __first1,
		141	_Sent1 __sent1,
		142	_Iter2 __first2,
		143	_Sent2 __sent2,
		144	_Pred& __pred,
		145	_Proj1& __proj1,
		146	_Proj2& __proj2,
		147	random_access_iterator_tag,
		148	random_access_iterator_tag) {
		149	typedef typename iterator_traits<_Iter1>::difference_type _D1;
		150	auto __last1 = _IterOps<_AlgPolicy>::next(__first1, __sent1);
		151	auto __last2 = _IterOps<_AlgPolicy>::next(__first2, __sent2);
		152	// Take advantage of knowing source and pattern lengths. Stop short when source is smaller than pattern
		153	auto __len2 = __last2 - __first2;
		154	if (__len2 == 0)
		155	return std::make_pair(__last1, __last1);
		156	auto __len1 = __last1 - __first1;
		157	if (__len1 < __len2)
		158	return std::make_pair(__last1, __last1);
		159	const _Iter1 __s = __first1 + _D1(__len2 - 1); // End of pattern match can't go before here
		160	_Iter1 __l1 = __last1;
		161	_Iter2 __l2 = __last2;
		162	--__l2;
		163	while (true) {
		164	while (true) {
		165	if (__s == __l1)
		166	return std::make_pair(__last1, __last1);
		167	if (std::__invoke(__pred, std::__invoke(__proj1, --__l1), std::__invoke(__proj2, __l2)))
		168	break;
		169	}
		170	_Iter1 __last_match = __l1;
		171	_Iter1 __m1 = __l1;
		172	_Iter2 __m2 = __l2;
		173	while (true) {
		174	if (__m2 == __first2)
		175	return std::make_pair(__m1, ++__last_match);
		176	// no need to check range on __m1 because __s guarantees we have enough source
		177	if (!std::__invoke(__pred, std::__invoke(__proj1, --__m1), std::__invoke(__proj2, --__m2))) {
		178	break;
		179	}
		180	}
		181	}
		182	}
		183
79	template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>	184	template <class _ForwardIterator1, class _ForwardIterator2, class _BinaryPredicate>
80	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator1 __find_end_classic(	185	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _ForwardIterator1 __find_end_classic(
81	_ForwardIterator1 __first1,	186	_ForwardIterator1 __first1,

lib/libcxx/include/__algorithm/for_each.h+18-24

 @@ -11,45 +11,41 @@
 #define _LIBCPP___ALGORITHM_FOR_EACH_H
 #include <__algorithm/for_each_segment.h>
+#include <__algorithm/specialized_algorithms.h>
 #include <__config>
 #include <__functional/identity.h>
 #include <__iterator/segmented_iterator.h>
-#include <__type_traits/enable_if.h>
 #include <__type_traits/invoke.h>
-#include <__utility/move.h>
+#include <__type_traits/is_same.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
-_LIBCPP_PUSH_MACROS
-#include <__undef_macros>
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _InputIterator, class _Sent, class _Func, class _Proj>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
-__for_each(_InputIterator __first, _Sent __last, _Func& __f, _Proj& __proj) {
+__for_each(_InputIterator __first, _Sent __last, _Func& __func, _Proj& __proj) {
+#ifndef _LIBCPP_CXX03_LANG
+  if constexpr (using _SpecialAlg =
+                    __specialized_algorithm<_Algorithm::__for_each, __iterator_pair<_InputIterator, _Sent>>;
+                _SpecialAlg::__has_algorithm) {
+    _SpecialAlg()(__first, __last, __func, __proj);
+    return __last;
+  } else if constexpr (is_same<_InputIterator, _Sent>::value && __is_segmented_iterator_v<_InputIterator>) {
+    using __local_iterator_t = typename __segmented_iterator_traits<_InputIterator>::__local_iterator;
+    std::__for_each_segment(__first, __last, [&](__local_iterator_t __lfirst, __local_iterator_t __llast) {
+      std::__for_each(__lfirst, __llast, __func, __proj);
+    });
+    return __last;
+  }
+#endif
   for (; __first != __last; ++__first)
-    std::__invoke(__f, std::__invoke(__proj, *__first));
+    std::__invoke(__func, std::__invoke(__proj, *__first));
   return __first;
 }
-#ifndef _LIBCPP_CXX03_LANG
-template <class _SegmentedIterator,
-          class _Func,
-          class _Proj,
-          __enable_if_t<__is_segmented_iterator<_SegmentedIterator>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _SegmentedIterator
-__for_each(_SegmentedIterator __first, _SegmentedIterator __last, _Func& __func, _Proj& __proj) {
-  using __local_iterator_t = typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator;
-  std::__for_each_segment(__first, __last, [&](__local_iterator_t __lfirst, __local_iterator_t __llast) {
-    std::__for_each(__lfirst, __llast, __func, __proj);
-  });
-  return __last;
-}
-#endif // !_LIBCPP_CXX03_LANG
 template <class _InputIterator, class _Func>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Func
 for_each(_InputIterator __first, _InputIterator __last, _Func __f) {
 @@ -60,6 +56,4 @@ for_each(_InputIterator __first, _InputIterator __last, _Func __f) {
 _LIBCPP_END_NAMESPACE_STD
-_LIBCPP_POP_MACROS
 #endif // _LIBCPP___ALGORITHM_FOR_EACH_H

lib/libcxx/include/__algorithm/for_each_n.h+20-47

 @@ -16,10 +16,7 @@
 #include <__functional/identity.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/segmented_iterator.h>
-#include <__type_traits/disjunction.h>
-#include <__type_traits/enable_if.h>
 #include <__type_traits/invoke.h>
-#include <__type_traits/negation.h>
 #include <__utility/convert_to_integral.h>
 #include <__utility/move.h>
 @@ -32,57 +29,33 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <class _InputIterator,
+template <class _InputIterator, class _Size, class _Func, class _Proj>
-          class _Size,
-          class _Func,
-          class _Proj,
-          __enable_if_t<!__has_random_access_iterator_category<_InputIterator>::value &&
-                            _Or< _Not<__is_segmented_iterator<_InputIterator> >,
-                                 _Not<__has_random_access_local_iterator<_InputIterator> > >::value,
-                        int> = 0>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _InputIterator
 __for_each_n(_InputIterator __first, _Size __orig_n, _Func& __f, _Proj& __proj) {
   typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
   _IntegralSize __n = __orig_n;
-  while (__n > 0) {
-    std::__invoke(__f, std::__invoke(__proj, *__first));
-    ++__first;
-    --__n;
-  }
-  return std::move(__first);
-}
-template <class _RandIter,
-          class _Size,
-          class _Func,
-          class _Proj,
-          __enable_if_t<__has_random_access_iterator_category<_RandIter>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandIter
-__for_each_n(_RandIter __first, _Size __orig_n, _Func& __f, _Proj& __proj) {
-  typename std::iterator_traits<_RandIter>::difference_type __n = __orig_n;
-  auto __last                                                   = __first + __n;
-  std::__for_each(__first, __last, __f, __proj);
-  return __last;
-}
 #ifndef _LIBCPP_CXX03_LANG
-template <class _SegmentedIterator,
+  if constexpr (__is_segmented_iterator_v<_InputIterator>) {
-          class _Size,
+    using __local_iterator = typename __segmented_iterator_traits<_InputIterator>::__local_iterator;
-          class _Func,
+    if constexpr (__has_random_access_iterator_category<__local_iterator>::value) {
-          class _Proj,
+      return std::__for_each_n_segment(__first, __orig_n, [&](__local_iterator __lfirst, __local_iterator __llast) {
-          __enable_if_t<!__has_random_access_iterator_category<_SegmentedIterator>::value &&
+        std::__for_each(__lfirst, __llast, __f, __proj);
-                            __is_segmented_iterator<_SegmentedIterator>::value &&
+      });
-                            __has_random_access_iterator_category<
+    } else {
-                                typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator>::value,
+      return std::__for_each(__first, __first + __n, __f, __proj);
-                        int> = 0>
+    }
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _SegmentedIterator
+  } else
-__for_each_n(_SegmentedIterator __first, _Size __orig_n, _Func& __f, _Proj& __proj) {
+#endif
-  using __local_iterator_t = typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator;
+  {
-  return std::__for_each_n_segment(__first, __orig_n, [&](__local_iterator_t __lfirst, __local_iterator_t __llast) {
+    while (__n > 0) {
-    std::__for_each(__lfirst, __llast, __f, __proj);
+      std::__invoke(__f, std::__invoke(__proj, *__first));
-  });
+      ++__first;
+      --__n;
+    }
+    return std::move(__first);
+  }
 }
-#endif // !_LIBCPP_CXX03_LANG
 #if _LIBCPP_STD_VER >= 17

lib/libcxx/include/__algorithm/for_each_n_segment.h+1-1

...	@@ -27,7 +27,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -27,7 +27,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
27	template <class _SegmentedIterator, class _Size, class _Functor>	27	template <class _SegmentedIterator, class _Size, class _Functor>
28	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator	28	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _SegmentedIterator
29	__for_each_n_segment(_SegmentedIterator __first, _Size __orig_n, _Functor __func) {	29	__for_each_n_segment(_SegmentedIterator __first, _Size __orig_n, _Functor __func) {
30	static_assert(__is_segmented_iterator<_SegmentedIterator>::value &&	30	static_assert(__is_segmented_iterator_v<_SegmentedIterator> &&
31	__has_random_access_iterator_category<	31	__has_random_access_iterator_category<
32	typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator>::value,	32	typename __segmented_iterator_traits<_SegmentedIterator>::__local_iterator>::value,
33	"__for_each_n_segment only works with segmented iterators with random-access local iterators");	33	"__for_each_n_segment only works with segmented iterators with random-access local iterators");

lib/libcxx/include/__algorithm/for_each_segment.h+26

...	@@ -48,6 +48,32 @@ __for_each_segment(_SegmentedIterator __first, _SegmentedIterator __last, _Funct	...	@@ -48,6 +48,32 @@ __for_each_segment(_SegmentedIterator __first, _SegmentedIterator __last, _Funct
48	__func(_Traits::__begin(__sfirst), _Traits::__local(__last));	48	__func(_Traits::__begin(__sfirst), _Traits::__local(__last));
49	}	49	}
50		50
		51	template <class _SegmentedIterator, class _Functor>
		52	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
		53	__for_each_segment_backward(_SegmentedIterator __first, _SegmentedIterator __last, _Functor __func) {
		54	using _Traits = __segmented_iterator_traits<_SegmentedIterator>;
		55
		56	auto __sfirst = _Traits::__segment(__first);
		57	auto __slast = _Traits::__segment(__last);
		58
		59	// We are in a single segment, so we might not be at the beginning or end
		60	if (__sfirst == __slast) {
		61	__func(_Traits::__local(__first), _Traits::__local(__last));
		62	return;
		63	}
		64
		65	// We have more than one segment. Iterate over the last segment, since we might not start at the end
		66	__func(_Traits::__begin(__slast), _Traits::__local(__last));
		67	--__slast;
		68	// iterate over the segments which are guaranteed to be completely in the range
		69	while (__sfirst != __slast) {
		70	__func(_Traits::__begin(__slast), _Traits::__end(__slast));
		71	--__slast;
		72	}
		73	// iterate over the first segment
		74	__func(_Traits::__local(__first), _Traits::__end(__slast));
		75	}
		76
51	_LIBCPP_END_NAMESPACE_STD	77	_LIBCPP_END_NAMESPACE_STD
52		78
53	#endif // _LIBCPP___ALGORITHM_FOR_EACH_SEGMENT_H	79	#endif // _LIBCPP___ALGORITHM_FOR_EACH_SEGMENT_H

lib/libcxx/include/__algorithm/generate.h+4-2

...	@@ -9,7 +9,9 @@	...	@@ -9,7 +9,9 @@
9	#ifndef _LIBCPP___ALGORITHM_GENERATE_H	9	#ifndef _LIBCPP___ALGORITHM_GENERATE_H
10	#define _LIBCPP___ALGORITHM_GENERATE_H	10	#define _LIBCPP___ALGORITHM_GENERATE_H
11		11
		12	#include <__algorithm/for_each.h>
12	#include <__config>	13	#include <__config>
		14	#include <__utility/forward.h>
13		15
14	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	16	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15	# pragma GCC system_header	17	# pragma GCC system_header
...	@@ -20,8 +22,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -20,8 +22,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
20	template <class _ForwardIterator, class _Generator>	22	template <class _ForwardIterator, class _Generator>
21	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void	23	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
22	generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {	24	generate(_ForwardIterator __first, _ForwardIterator __last, _Generator __gen) {
23	for (; __first != __last; ++__first)	25	using __iter_ref = decltype(*__first);
24	*__first = __gen();	26	std::for_each(__first, __last, [&](__iter_ref __element) { std::forward<__iter_ref>(__element) = __gen(); });
25	}	27	}
26		28
27	_LIBCPP_END_NAMESPACE_STD	29	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__algorithm/generate_n.h+19-6

 @@ -9,25 +9,38 @@
 #ifndef _LIBCPP___ALGORITHM_GENERATE_N_H
 #define _LIBCPP___ALGORITHM_GENERATE_N_H
+#include <__algorithm/for_each_n.h>
 #include <__config>
-#include <__utility/convert_to_integral.h>
+#include <__functional/identity.h>
+#include <__utility/forward.h>
+#include <__utility/move.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 _LIBCPP_BEGIN_NAMESPACE_STD
+template <class _OutputIterator, class _Size, class _Generator>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
+__generate_n(_OutputIterator __first, _Size __orig_n, _Generator& __gen) {
+  using __iter_ref = decltype(*__first);
+  __identity __proj;
+  auto __f = [&](__iter_ref __element) { std::forward<__iter_ref>(__element) = __gen(); };
+  return std::__for_each_n(std::move(__first), __orig_n, __f, __proj);
+}
 template <class _OutputIterator, class _Size, class _Generator>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _OutputIterator
 generate_n(_OutputIterator __first, _Size __orig_n, _Generator __gen) {
-  typedef decltype(std::__convert_to_integral(__orig_n)) _IntegralSize;
+  return std::__generate_n(std::move(__first), __orig_n, __gen);
-  _IntegralSize __n = __orig_n;
-  for (; __n > 0; ++__first, (void)--__n)
-    *__first = __gen();
-  return __first;
 }
 _LIBCPP_END_NAMESPACE_STD
+_LIBCPP_POP_MACROS
 #endif // _LIBCPP___ALGORITHM_GENERATE_N_H

lib/libcxx/include/__algorithm/is_permutation.h+4-4

...	@@ -78,7 +78,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation_impl(	...	@@ -78,7 +78,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation_impl(
78	_Pred&& __pred,	78	_Pred&& __pred,
79	_Proj1&& __proj1,	79	_Proj1&& __proj1,
80	_Proj2&& __proj2) {	80	_Proj2&& __proj2) {
81	using _D1 = __iter_diff_t<_Iter1>;	81	using _D1 = __iterator_difference_type<_Iter1>;
82		82
83	for (auto __i = __first1; __i != __last1; ++__i) {	83	for (auto __i = __first1; __i != __last1; ++__i) {
84	// Have we already counted the number of *__i in [f1, l1)?	84	// Have we already counted the number of *__i in [f1, l1)?
...	@@ -126,7 +126,7 @@ template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _Fo	...	@@ -126,7 +126,7 @@ template <class _AlgPolicy, class _ForwardIterator1, class _Sentinel1, class _Fo
126	return true;	126	return true;
127		127
128	// __first1 != __last1 && __first1 != __first2	128	// __first1 != __last1 && __first1 != __first2
129	using _D1 = __iter_diff_t<_ForwardIterator1>;	129	using _D1 = __iterator_difference_type<_ForwardIterator1>;
130	_D1 __l1 = _IterOps<_AlgPolicy>::distance(__first1, __last1);	130	_D1 __l1 = _IterOps<_AlgPolicy>::distance(__first1, __last1);
131	if (__l1 == _D1(1))	131	if (__l1 == _D1(1))
132	return false;	132	return false;
...	@@ -173,10 +173,10 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation(	...	@@ -173,10 +173,10 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool __is_permutation(
173	if (__first2 == __last2) // Second range is shorter	173	if (__first2 == __last2) // Second range is shorter
174	return false;	174	return false;
175		175
176	using _D1 = __iter_diff_t<_Iter1>;	176	using _D1 = __iterator_difference_type<_Iter1>;
177	_D1 __l1 = _IterOps<_AlgPolicy>::distance(__first1, __last1);	177	_D1 __l1 = _IterOps<_AlgPolicy>::distance(__first1, __last1);
178		178
179	using _D2 = __iter_diff_t<_Iter2>;	179	using _D2 = __iterator_difference_type<_Iter2>;
180	_D2 __l2 = _IterOps<_AlgPolicy>::distance(__first2, __last2);	180	_D2 __l2 = _IterOps<_AlgPolicy>::distance(__first2, __last2);
181	if (__l1 != __l2)	181	if (__l1 != __l2)
182	return false;	182	return false;

lib/libcxx/include/__algorithm/iterator_operations.h+3

...	@@ -219,6 +219,9 @@ private:	...	@@ -219,6 +219,9 @@ private:
219	template <class _AlgPolicy, class _Iter>	219	template <class _AlgPolicy, class _Iter>
220	using __policy_iter_diff_t _LIBCPP_NODEBUG = typename _IterOps<_AlgPolicy>::template __difference_type<_Iter>;	220	using __policy_iter_diff_t _LIBCPP_NODEBUG = typename _IterOps<_AlgPolicy>::template __difference_type<_Iter>;
221		221
		222	template <class _AlgPolicy, class _Iter>
		223	using __policy_value_type _LIBCPP_NODEBUG = typename _IterOps<_AlgPolicy>::template __value_type<_Iter>;
		224
222	_LIBCPP_END_NAMESPACE_STD	225	_LIBCPP_END_NAMESPACE_STD
223		226
224	_LIBCPP_POP_MACROS	227	_LIBCPP_POP_MACROS

lib/libcxx/include/__algorithm/lexicographical_compare.h+2-2

...	@@ -66,8 +66,8 @@ template <class _Tp,	...	@@ -66,8 +66,8 @@ template <class _Tp,
66	class _Proj2,	66	class _Proj2,
67	class _Comp,	67	class _Comp,
68	__enable_if_t<__desugars_to_v<__totally_ordered_less_tag, _Comp, _Tp, _Tp> && !is_volatile<_Tp>::value &&	68	__enable_if_t<__desugars_to_v<__totally_ordered_less_tag, _Comp, _Tp, _Tp> && !is_volatile<_Tp>::value &&
69	__libcpp_is_trivially_equality_comparable<_Tp, _Tp>::value &&	69	__is_trivially_equality_comparable_v<_Tp, _Tp> && __is_identity<_Proj1>::value &&
70	__is_identity<_Proj1>::value && __is_identity<_Proj2>::value,	70	__is_identity<_Proj2>::value,
71	int> = 0>	71	int> = 0>
72	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool	72	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
73	__lexicographical_compare(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Tp* __last2, _Comp&, _Proj1&, _Proj2&) {	73	__lexicographical_compare(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Tp* __last2, _Comp&, _Proj1&, _Proj2&) {

lib/libcxx/include/__algorithm/lexicographical_compare_three_way.h+6-6

...	@@ -37,13 +37,13 @@ template <class _InputIterator1, class _InputIterator2, class _Cmp>	...	@@ -37,13 +37,13 @@ template <class _InputIterator1, class _InputIterator2, class _Cmp>
37	_LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path(	37	_LIBCPP_HIDE_FROM_ABI constexpr auto __lexicographical_compare_three_way_fast_path(
38	_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Cmp& __comp)	38	_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2, _Cmp& __comp)
39	-> decltype(__comp(__first1, __first2)) {	39	-> decltype(__comp(__first1, __first2)) {
40	static_assert(	40	static_assert(signed_integral<__iterator_difference_type<_InputIterator1>>,
41	signed_integral<__iter_diff_t<_InputIterator1>>, "Using a non-integral difference_type is undefined behavior.");	41	"Using a non-integral difference_type is undefined behavior.");
42	static_assert(	42	static_assert(signed_integral<__iterator_difference_type<_InputIterator2>>,
43	signed_integral<__iter_diff_t<_InputIterator2>>, "Using a non-integral difference_type is undefined behavior.");	43	"Using a non-integral difference_type is undefined behavior.");
44		44
45	using _Len1 = __iter_diff_t<_InputIterator1>;	45	using _Len1 = __iterator_difference_type<_InputIterator1>;
46	using _Len2 = __iter_diff_t<_InputIterator2>;	46	using _Len2 = __iterator_difference_type<_InputIterator2>;
47	using _Common = common_type_t<_Len1, _Len2>;	47	using _Common = common_type_t<_Len1, _Len2>;
48		48
49	_Len1 __len1 = __last1 - __first1;	49	_Len1 __len1 = __last1 - __first1;

lib/libcxx/include/__algorithm/make_heap.h+16-4

...	@@ -12,9 +12,11 @@	...	@@ -12,9 +12,11 @@
12	#include <__algorithm/comp.h>	12	#include <__algorithm/comp.h>
13	#include <__algorithm/comp_ref_type.h>	13	#include <__algorithm/comp_ref_type.h>
14	#include <__algorithm/iterator_operations.h>	14	#include <__algorithm/iterator_operations.h>
		15	#include <__algorithm/push_heap.h>
15	#include <__algorithm/sift_down.h>	16	#include <__algorithm/sift_down.h>
16	#include <__config>	17	#include <__config>
17	#include <__iterator/iterator_traits.h>	18	#include <__iterator/iterator_traits.h>
		19	#include <__type_traits/is_arithmetic.h>
18	#include <__utility/move.h>	20	#include <__utility/move.h>
19		21
20	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	22	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -31,13 +33,23 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void	...	@@ -31,13 +33,23 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
31	__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {	33	__make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare&& __comp) {
32	__comp_ref_type<_Compare> __comp_ref = __comp;	34	__comp_ref_type<_Compare> __comp_ref = __comp;
33		35
34	using difference_type = typename iterator_traits<_RandomAccessIterator>::difference_type;	36	using __diff_t = __iterator_difference_type<_RandomAccessIterator>;
35	difference_type __n = __last - __first;	37	const __diff_t __n = __last - __first;
		38
		39	const bool __assume_both_children = is_arithmetic<__iterator_value_type<_RandomAccessIterator> >::value;
		40
		41	// While it would be correct to always assume we have both children, in practice we observed this to be a performance
		42	// improvement only for arithmetic types.
		43	const __diff_t __sift_down_n = __assume_both_children ? ((__n & 1) ? __n : __n - 1) : __n;
		44
36	if (__n > 1) {	45	if (__n > 1) {
37	// start from the first parent, there is no need to consider children	46	// start from the first parent, there is no need to consider children
38	for (difference_type __start = (__n - 2) / 2; __start >= 0; --__start) {	47
39	std::__sift_down<_AlgPolicy>(__first, __comp_ref, __n, __first + __start);	48	for (__diff_t __start = (__sift_down_n - 2) / 2; __start >= 0; --__start) {
		49	std::__sift_down<_AlgPolicy, __assume_both_children>(__first, __comp_ref, __sift_down_n, __start);
40	}	50	}
		51	if _LIBCPP_CONSTEXPR (__assume_both_children)
		52	std::__sift_up<_AlgPolicy>(__first, __last, __comp, __n);
41	}	53	}
42	}	54	}
43		55

lib/libcxx/include/__algorithm/mismatch.h+2-2

lib/libcxx/include/__algorithm/move.h+8-19

 @@ -50,37 +50,26 @@ struct __move_impl {
     return std::make_pair(std::move(__first), std::move(__result));
   }
-  template <class _InIter, class _OutIter>
+  template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator_v<_InIter>, int> = 0>
-  struct _MoveSegment {
-    using _Traits _LIBCPP_NODEBUG = __segmented_iterator_traits<_InIter>;
-    _OutIter& __result_;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit _MoveSegment(_OutIter& __result)
-        : __result_(__result) {}
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
-    operator()(typename _Traits::__local_iterator __lfirst, typename _Traits::__local_iterator __llast) {
-      __result_ = std::__move<_AlgPolicy>(__lfirst, __llast, std::move(__result_)).second;
-    }
-  };
-  template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator<_InIter>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __last, _OutIter __result) const {
-    std::__for_each_segment(__first, __last, _MoveSegment<_InIter, _OutIter>(__result));
+    using __local_iterator = typename __segmented_iterator_traits<_InIter>::__local_iterator;
+    std::__for_each_segment(__first, __last, [&__result](__local_iterator __lfirst, __local_iterator __llast) {
+      __result = std::__move<_AlgPolicy>(__lfirst, __llast, std::move(__result)).second;
+    });
     return std::make_pair(__last, std::move(__result));
   }
   template <class _InIter,
             class _OutIter,
             __enable_if_t<__has_random_access_iterator_category<_InIter>::value &&
-                              !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
+                              !__is_segmented_iterator_v<_InIter> && __is_segmented_iterator_v<_OutIter>,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __last, _OutIter __result) const {
     using _Traits = __segmented_iterator_traits<_OutIter>;
-    using _DiffT  = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;
+    using _DiffT =
+        typename common_type<__iterator_difference_type<_InIter>, __iterator_difference_type<_OutIter> >::type;
     if (__first == __last)
       return std::make_pair(std::move(__first), std::move(__result));

lib/libcxx/include/__algorithm/move_backward.h+9-24

 @@ -11,6 +11,7 @@
 #include <__algorithm/copy_backward.h>
 #include <__algorithm/copy_move_common.h>
+#include <__algorithm/for_each_segment.h>
 #include <__algorithm/iterator_operations.h>
 #include <__algorithm/min.h>
 #include <__config>
 @@ -51,42 +52,26 @@ struct __move_backward_impl {
     return std::make_pair(std::move(__original_last_iter), std::move(__result));
   }
-  template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator<_InIter>::value, int> = 0>
+  template <class _InIter, class _OutIter, __enable_if_t<__is_segmented_iterator_v<_InIter>, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __last, _OutIter __result) const {
-    using _Traits = __segmented_iterator_traits<_InIter>;
+    using __local_iterator = typename __segmented_iterator_traits<_InIter>::__local_iterator;
-    auto __sfirst = _Traits::__segment(__first);
+    std::__for_each_segment_backward(__first, __last, [&__result](__local_iterator __lfirst, __local_iterator __llast) {
-    auto __slast  = _Traits::__segment(__last);
+      __result = std::__move_backward<_AlgPolicy>(std::move(__lfirst), std::move(__llast), std::move(__result)).second;
-    if (__sfirst == __slast) {
+    });
-      auto __iters =
-          std::__move_backward<_AlgPolicy>(_Traits::__local(__first), _Traits::__local(__last), std::move(__result));
-      return std::make_pair(__last, __iters.second);
-    }
-    __result =
-        std::__move_backward<_AlgPolicy>(_Traits::__begin(__slast), _Traits::__local(__last), std::move(__result))
-            .second;
-    --__slast;
-    while (__sfirst != __slast) {
-      __result =
-          std::__move_backward<_AlgPolicy>(_Traits::__begin(__slast), _Traits::__end(__slast), std::move(__result))
-              .second;
-      --__slast;
-    }
-    __result = std::__move_backward<_AlgPolicy>(_Traits::__local(__first), _Traits::__end(__slast), std::move(__result))
-                   .second;
     return std::make_pair(__last, std::move(__result));
   }
   template <class _InIter,
             class _OutIter,
             __enable_if_t<__has_random_access_iterator_category<_InIter>::value &&
-                              !__is_segmented_iterator<_InIter>::value && __is_segmented_iterator<_OutIter>::value,
+                              !__is_segmented_iterator_v<_InIter> && __is_segmented_iterator_v<_OutIter>,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_InIter, _OutIter>
   operator()(_InIter __first, _InIter __last, _OutIter __result) const {
     using _Traits = __segmented_iterator_traits<_OutIter>;
-    using _DiffT  = typename common_type<__iter_diff_t<_InIter>, __iter_diff_t<_OutIter> >::type;
+    using _DiffT =
+        typename common_type<__iterator_difference_type<_InIter>, __iterator_difference_type<_OutIter> >::type;
     // When the range contains no elements, __result might not be a valid iterator
     if (__first == __last)

lib/libcxx/include/__algorithm/none_of.h+4-4

 @@ -10,7 +10,9 @@
 #ifndef _LIBCPP___ALGORITHM_NONE_OF_H
 #define _LIBCPP___ALGORITHM_NONE_OF_H
+#include <__algorithm/any_of.h>
 #include <__config>
+#include <__functional/identity.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 @@ -21,10 +23,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _InputIterator, class _Predicate>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool
 none_of(_InputIterator __first, _InputIterator __last, _Predicate __pred) {
-  for (; __first != __last; ++__first)
+  __identity __proj;
-    if (__pred(*__first))
+  return !std::__any_of(__first, __last, __pred, __proj);
-      return false;
-  return true;
 }
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__algorithm/partial_sort.h+1-1

...	@@ -45,7 +45,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __part	...	@@ -45,7 +45,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _RandomAccessIterator __part
45	for (; __i != __last; ++__i) {	45	for (; __i != __last; ++__i) {
46	if (__comp(__i, __first)) {	46	if (__comp(__i, __first)) {
47	_IterOps<_AlgPolicy>::iter_swap(__i, __first);	47	_IterOps<_AlgPolicy>::iter_swap(__i, __first);
48	std::__sift_down<_AlgPolicy>(__first, __comp, __len, __first);	48	std::__sift_down<_AlgPolicy, false>(__first, __comp, __len, 0);
49	}	49	}
50	}	50	}
51	std::__sort_heap<_AlgPolicy>(std::move(__first), std::move(__middle), __comp);	51	std::__sort_heap<_AlgPolicy>(std::move(__first), std::move(__middle), __comp);

lib/libcxx/include/__algorithm/partial_sort_copy.h+1-1

...	@@ -60,7 +60,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator, _Random	...	@@ -60,7 +60,7 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_InputIterator, _Random
60	for (; __first != __last; ++__first)	60	for (; __first != __last; ++__first)
61	if (std::__invoke(__comp, std::__invoke(__proj1, __first), std::__invoke(__proj2, __result_first))) {	61	if (std::__invoke(__comp, std::__invoke(__proj1, __first), std::__invoke(__proj2, __result_first))) {
62	__result_first = __first;	62	__result_first = __first;
63	std::__sift_down<_AlgPolicy>(__result_first, __projected_comp, __len, __result_first);	63	std::__sift_down<_AlgPolicy, false>(__result_first, __projected_comp, __len, 0);
64	}	64	}
65	std::__sort_heap<_AlgPolicy>(__result_first, __r, __projected_comp);	65	std::__sort_heap<_AlgPolicy>(__result_first, __r, __projected_comp);
66	}	66	}

lib/libcxx/include/__algorithm/pstl.h+9-9

lib/libcxx/include/__algorithm/radix_sort.h+27-25

 @@ -72,14 +72,14 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 14
 template <class _InputIterator, class _OutputIterator>
-_LIBCPP_HIDE_FROM_ABI constexpr pair<_OutputIterator, __iter_value_type<_InputIterator>>
+_LIBCPP_HIDE_FROM_ABI constexpr pair<_OutputIterator, __iterator_value_type<_InputIterator>>
 __partial_sum_max(_InputIterator __first, _InputIterator __last, _OutputIterator __result) {
   if (__first == __last)
     return {__result, 0};
-  auto __max                              = *__first;
+  auto __max                                  = *__first;
-  __iter_value_type<_InputIterator> __sum = *__first;
+  __iterator_value_type<_InputIterator> __sum = *__first;
-  *__result                               = __sum;
+  *__result                                   = __sum;
   while (++__first != __last) {
     if (__max < *__first) {
 @@ -124,7 +124,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __nth_radix(size_t __radix_number, _Radix _
 template <class _ForwardIterator, class _Map, class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI constexpr void
 __collect(_ForwardIterator __first, _ForwardIterator __last, _Map __map, _RandomAccessIterator __counters) {
-  using __value_type = __iter_value_type<_ForwardIterator>;
+  using __value_type = __iterator_value_type<_ForwardIterator>;
   using __traits     = __counting_sort_traits<__value_type, _Map>;
   std::for_each(__first, __last, [&__counters, &__map](const auto& __preimage) { ++__counters[__map(__preimage)]; });
 @@ -160,7 +160,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __collect_impl(
     _RandomAccessIterator1 __counters,
     _RandomAccessIterator2 __maximums,
     index_sequence<_Radices...>) {
-  using __value_type                 = __iter_value_type<_ForwardIterator>;
+  using __value_type                 = __iterator_value_type<_ForwardIterator>;
   constexpr auto __radix_value_range = __radix_sort_traits<__value_type, _Map, _Radix>::__radix_value_range;
   auto __previous  = numeric_limits<__invoke_result_t<_Map, __value_type>>::min();
 @@ -189,7 +189,7 @@ __collect(_ForwardIterator __first,
           _Radix __radix,
           _RandomAccessIterator1 __counters,
           _RandomAccessIterator2 __maximums) {
-  using __value_type           = __iter_value_type<_ForwardIterator>;
+  using __value_type           = __iterator_value_type<_ForwardIterator>;
   constexpr auto __radix_count = __radix_sort_traits<__value_type, _Map, _Radix>::__radix_count;
   return std::__collect_impl(
       __first, __last, __map, __radix, __counters, __maximums, make_index_sequence<__radix_count>());
 @@ -213,10 +213,10 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __dispose_backward(
 template <class _ForwardIterator, class _RandomAccessIterator, class _Map>
 _LIBCPP_HIDE_FROM_ABI constexpr _RandomAccessIterator
 __counting_sort_impl(_ForwardIterator __first, _ForwardIterator __last, _RandomAccessIterator __result, _Map __map) {
-  using __value_type = __iter_value_type<_ForwardIterator>;
+  using __value_type = __iterator_value_type<_ForwardIterator>;
   using __traits     = __counting_sort_traits<__value_type, _Map>;
-  __iter_diff_t<_RandomAccessIterator> __counters[__traits::__value_range + 1] = {0};
+  __iterator_difference_type<_RandomAccessIterator> __counters[__traits::__value_range + 1] = {0};
   std::__collect(__first, __last, __map, std::next(std::begin(__counters)));
   std::__dispose(__first, __last, __result, __map, std::begin(__counters));
 @@ -224,12 +224,13 @@ __counting_sort_impl(_ForwardIterator __first, _ForwardIterator __last, _RandomA
   return __result + __counters[__traits::__value_range];
 }
-template <class _RandomAccessIterator1,
+template <
-          class _RandomAccessIterator2,
+    class _RandomAccessIterator1,
-          class _Map,
+    class _RandomAccessIterator2,
-          class _Radix,
+    class _Map,
-          enable_if_t< __radix_sort_traits<__iter_value_type<_RandomAccessIterator1>, _Map, _Radix>::__radix_count == 1,
+    class _Radix,
-                       int> = 0>
+    enable_if_t<__radix_sort_traits<__iterator_value_type<_RandomAccessIterator1>, _Map, _Radix>::__radix_count == 1,
+                int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr void __radix_sort_impl(
     _RandomAccessIterator1 __first,
     _RandomAccessIterator1 __last,
 @@ -243,24 +244,25 @@ _LIBCPP_HIDE_FROM_ABI constexpr void __radix_sort_impl(
   std::move(__buffer, __buffer_end, __first);
 }
-template <
+template <class _RandomAccessIterator1,
-    class _RandomAccessIterator1,
+          class _RandomAccessIterator2,
-    class _RandomAccessIterator2,
+          class _Map,
-    class _Map,
+          class _Radix,
-    class _Radix,
+          enable_if_t<
-    enable_if_t< __radix_sort_traits<__iter_value_type<_RandomAccessIterator1>, _Map, _Radix>::__radix_count % 2 == 0,
+              __radix_sort_traits<__iterator_value_type<_RandomAccessIterator1>, _Map, _Radix>::__radix_count % 2 == 0,
-                 int> = 0 >
+              int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr void __radix_sort_impl(
     _RandomAccessIterator1 __first,
     _RandomAccessIterator1 __last,
     _RandomAccessIterator2 __buffer_begin,
     _Map __map,
     _Radix __radix) {
-  using __value_type = __iter_value_type<_RandomAccessIterator1>;
+  using __value_type = __iterator_value_type<_RandomAccessIterator1>;
   using __traits     = __radix_sort_traits<__value_type, _Map, _Radix>;
-  __iter_diff_t<_RandomAccessIterator1> __counters[__traits::__radix_count][__traits::__radix_value_range] = {{0}};
+  __iterator_difference_type<_RandomAccessIterator1>
-  __iter_diff_t<_RandomAccessIterator1> __maximums[__traits::__radix_count]                                = {0};
+      __counters[__traits::__radix_count][__traits::__radix_value_range]                 = {{0}};
+  __iterator_difference_type<_RandomAccessIterator1> __maximums[__traits::__radix_count] = {0};
   const auto __is_sorted = std::__collect(__first, __last, __map, __radix, __counters, __maximums);
   if (!__is_sorted) {
     const auto __range_size = std::distance(__first, __last);

lib/libcxx/include/__algorithm/ranges_copy_n.h+3-26

...	@@ -9,16 +9,12 @@	...	@@ -9,16 +9,12 @@
9	#ifndef _LIBCPP___ALGORITHM_RANGES_COPY_N_H	9	#ifndef _LIBCPP___ALGORITHM_RANGES_COPY_N_H
10	#define _LIBCPP___ALGORITHM_RANGES_COPY_N_H	10	#define _LIBCPP___ALGORITHM_RANGES_COPY_N_H
11		11
12	#include <__algorithm/copy.h>	12	#include <__algorithm/copy_n.h>
13	#include <__algorithm/in_out_result.h>	13	#include <__algorithm/in_out_result.h>
14	#include <__algorithm/iterator_operations.h>	14	#include <__algorithm/iterator_operations.h>
15	#include <__algorithm/ranges_copy.h>
16	#include <__config>	15	#include <__config>
17	#include <__functional/identity.h>
18	#include <__iterator/concepts.h>	16	#include <__iterator/concepts.h>
19	#include <__iterator/incrementable_traits.h>	17	#include <__iterator/incrementable_traits.h>
20	#include <__iterator/unreachable_sentinel.h>
21	#include <__iterator/wrap_iter.h>
22	#include <__utility/move.h>	18	#include <__utility/move.h>
23		19
24	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	20	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -37,32 +33,13 @@ namespace ranges {	...	@@ -37,32 +33,13 @@ namespace ranges {
37	template <class _Ip, class _Op>	33	template <class _Ip, class _Op>
38	using copy_n_result = in_out_result<_Ip, _Op>;	34	using copy_n_result = in_out_result<_Ip, _Op>;
39		35
40	// TODO: Merge this with copy_n
41	struct __copy_n {	36	struct __copy_n {
42	template <class _InIter, class _DiffType, class _OutIter>
43	_LIBCPP_HIDE_FROM_ABI constexpr static copy_n_result<_InIter, _OutIter>
44	__go(_InIter __first, _DiffType __n, _OutIter __result) {
45	while (__n != 0) {
46	__result = __first;
47	++__first;
48	++__result;
49	--__n;
50	}
51	return {std::move(__first), std::move(__result)};
52	}
53
54	template <random_access_iterator _InIter, class _DiffType, random_access_iterator _OutIter>
55	_LIBCPP_HIDE_FROM_ABI constexpr static copy_n_result<_InIter, _OutIter>
56	__go(_InIter __first, _DiffType __n, _OutIter __result) {
57	auto __ret = std::__copy(__first, __first + __n, __result);
58	return {__ret.first, __ret.second};
59	}
60
61	template <input_iterator _Ip, weakly_incrementable _Op>	37	template <input_iterator _Ip, weakly_incrementable _Op>
62	requires indirectly_copyable<_Ip, _Op>	38	requires indirectly_copyable<_Ip, _Op>
63	_LIBCPP_HIDE_FROM_ABI constexpr copy_n_result<_Ip, _Op>	39	_LIBCPP_HIDE_FROM_ABI constexpr copy_n_result<_Ip, _Op>
64	operator()(_Ip __first, iter_difference_t<_Ip> __n, _Op __result) const {	40	operator()(_Ip __first, iter_difference_t<_Ip> __n, _Op __result) const {
65	return __go(std::move(__first), __n, std::move(__result));	41	auto __res = std::__copy_n<_RangeAlgPolicy>(std::move(__first), __n, std::move(__result));
		42	return {std::move(__res.first), std::move(__res.second)};
66	}	43	}
67	};	44	};
68		45

lib/libcxx/include/__algorithm/ranges_equal.h+17-26

...	@@ -13,13 +13,12 @@	...	@@ -13,13 +13,12 @@
13	#include <__algorithm/unwrap_range.h>	13	#include <__algorithm/unwrap_range.h>
14	#include <__config>	14	#include <__config>
15	#include <__functional/identity.h>	15	#include <__functional/identity.h>
16	#include <__functional/invoke.h>
17	#include <__functional/ranges_operations.h>	16	#include <__functional/ranges_operations.h>
18	#include <__iterator/concepts.h>	17	#include <__iterator/concepts.h>
19	#include <__iterator/distance.h>
20	#include <__iterator/indirectly_comparable.h>	18	#include <__iterator/indirectly_comparable.h>
21	#include <__ranges/access.h>	19	#include <__ranges/access.h>
22	#include <__ranges/concepts.h>	20	#include <__ranges/concepts.h>
		21	#include <__ranges/size.h>
23	#include <__utility/move.h>	22	#include <__utility/move.h>
24		23
25	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	24	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -51,20 +50,17 @@ struct __equal {	...	@@ -51,20 +50,17 @@ struct __equal {
51	_Pred __pred = {},	50	_Pred __pred = {},
52	_Proj1 __proj1 = {},	51	_Proj1 __proj1 = {},
53	_Proj2 __proj2 = {}) const {	52	_Proj2 __proj2 = {}) const {
54	if constexpr (sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2>) {	53	static constexpr bool __both_sized = sized_sentinel_for<_Sent1, _Iter1> && sized_sentinel_for<_Sent2, _Iter2>;
		54	if constexpr (__both_sized) {
55	if (__last1 - __first1 != __last2 - __first2)	55	if (__last1 - __first1 != __last2 - __first2)
56	return false;	56	return false;
57	}	57	}
58	auto __unwrapped1 = std::__unwrap_range(std::move(__first1), std::move(__last1));	58
59	auto __unwrapped2 = std::__unwrap_range(std::move(__first2), std::move(__last2));	59	auto [__ufirst1, __ulast1] = std::__unwrap_range(std::move(__first1), std::move(__last1));
60	return std::__equal_impl(	60	auto [__ufirst2, __ulast2] = std::__unwrap_range(std::move(__first2), std::move(__last2));
61	std::move(__unwrapped1.first),	61
62	std::move(__unwrapped1.second),	62	return std::__equal_impl<__both_sized>(
63	std::move(__unwrapped2.first),	63	std::move(__ufirst1), std::move(__ulast1), std::move(__ufirst2), std::move(__ulast2), __pred, __proj1, __proj2);
64	std::move(__unwrapped2.second),
65	__pred,
66	__proj1,
67	__proj2);
68	}	64	}
69		65
70	template <input_range _Range1,	66	template <input_range _Range1,
...	@@ -75,21 +71,16 @@ struct __equal {	...	@@ -75,21 +71,16 @@ struct __equal {
75	requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>	71	requires indirectly_comparable<iterator_t<_Range1>, iterator_t<_Range2>, _Pred, _Proj1, _Proj2>
76	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(	72	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool operator()(
77	_Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {	73	_Range1&& __range1, _Range2&& __range2, _Pred __pred = {}, _Proj1 __proj1 = {}, _Proj2 __proj2 = {}) const {
78	if constexpr (sized_range<_Range1> && sized_range<_Range2>) {	74	static constexpr bool __both_sized = sized_range<_Range1> && sized_range<_Range2>;
79	if (ranges::distance(__range1) != ranges::distance(__range2))	75	if constexpr (__both_sized) {
		76	if (ranges::size(__range1) != ranges::size(__range2))
80	return false;	77	return false;
81	}	78	}
82	auto __unwrapped1 = std::__unwrap_range(ranges::begin(__range1), ranges::end(__range1));	79
83	auto __unwrapped2 = std::__unwrap_range(ranges::begin(__range2), ranges::end(__range2));	80	auto [__ufirst1, __ulast1] = std::__unwrap_range(ranges::begin(__range1), ranges::end(__range1));
84	return std::__equal_impl(	81	auto [__ufirst2, __ulast2] = std::__unwrap_range(ranges::begin(__range2), ranges::end(__range2));
85	std::move(__unwrapped1.first),	82	return std::__equal_impl<__both_sized>(
86	std::move(__unwrapped1.second),	83	std::move(__ufirst1), std::move(__ulast1), std::move(__ufirst2), std::move(__ulast2), __pred, __proj1, __proj2);
87	std::move(__unwrapped2.first),
88	std::move(__unwrapped2.second),
89	__pred,
90	__proj1,
91	__proj2);
92	return false;
93	}	84	}
94	};	85	};
95		86

lib/libcxx/include/__algorithm/ranges_fill.h+7-6

 @@ -9,12 +9,14 @@
 #ifndef _LIBCPP___ALGORITHM_RANGES_FILL_H
 #define _LIBCPP___ALGORITHM_RANGES_FILL_H
-#include <__algorithm/ranges_fill_n.h>
+#include <__algorithm/fill.h>
+#include <__algorithm/fill_n.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
+#include <__utility/move.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 @@ -31,12 +33,11 @@ namespace ranges {
 struct __fill {
   template <class _Type, output_iterator<const _Type&> _Iter, sentinel_for<_Iter> _Sent>
   _LIBCPP_HIDE_FROM_ABI constexpr _Iter operator()(_Iter __first, _Sent __last, const _Type& __value) const {
-    if constexpr (random_access_iterator<_Iter> && sized_sentinel_for<_Sent, _Iter>) {
+    if constexpr (sized_sentinel_for<_Sent, _Iter>) {
-      return ranges::fill_n(__first, __last - __first, __value);
+      auto __n = __last - __first;
+      return std::__fill_n(std::move(__first), __n, __value);
     } else {
-      for (; __first != __last; ++__first)
+      return std::__fill(std::move(__first), std::move(__last), __value);
-        *__first = __value;
-      return __first;
     }
   }

lib/libcxx/include/__algorithm/ranges_for_each.h+9-1

 @@ -12,6 +12,7 @@
 #include <__algorithm/for_each.h>
 #include <__algorithm/for_each_n.h>
 #include <__algorithm/in_fun_result.h>
+#include <__algorithm/specialized_algorithms.h>
 #include <__concepts/assignable.h>
 #include <__config>
 #include <__functional/identity.h>
 @@ -20,6 +21,7 @@
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/dangling.h>
+#include <__type_traits/remove_cvref.h>
 #include <__utility/move.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 @@ -71,7 +73,13 @@ public:
             indirectly_unary_invocable<projected<iterator_t<_Range>, _Proj>> _Func>
   _LIBCPP_HIDE_FROM_ABI constexpr for_each_result<borrowed_iterator_t<_Range>, _Func>
   operator()(_Range&& __range, _Func __func, _Proj __proj = {}) const {
-    return __for_each_impl(ranges::begin(__range), ranges::end(__range), __func, __proj);
+    using _SpecialAlg = __specialized_algorithm<_Algorithm::__for_each, __single_range<remove_cvref_t<_Range>>>;
+    if constexpr (_SpecialAlg::__has_algorithm) {
+      auto [__iter, __func2] = _SpecialAlg()(__range, std::move(__func), std::move(__proj));
+      return {std::move(__iter), std::move(__func)};
+    } else {
+      return __for_each_impl(ranges::begin(__range), ranges::end(__range), __func, __proj);
+    }
   }
 };

lib/libcxx/include/__algorithm/ranges_generate_n.h+2-6

 @@ -9,6 +9,7 @@
 #ifndef _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H
 #define _LIBCPP___ALGORITHM_RANGES_GENERATE_N_H
+#include <__algorithm/generate_n.h>
 #include <__concepts/constructible.h>
 #include <__concepts/invocable.h>
 #include <__config>
 @@ -38,12 +39,7 @@ struct __generate_n {
     requires invocable<_Func&> && indirectly_writable<_OutIter, invoke_result_t<_Func&>>
   _LIBCPP_HIDE_FROM_ABI constexpr _OutIter
   operator()(_OutIter __first, iter_difference_t<_OutIter> __n, _Func __gen) const {
-    for (; __n > 0; --__n) {
+    return std::__generate_n(std::move(__first), __n, __gen);
-      *__first = __gen();
-      ++__first;
-    }
-    return __first;
   }
 };

lib/libcxx/include/__algorithm/ranges_search_n.h+2-2

...	@@ -54,8 +54,8 @@ struct __search_n {	...	@@ -54,8 +54,8 @@ struct __search_n {
54	}	54	}
55		55
56	if constexpr (random_access_iterator<_Iter1>) {	56	if constexpr (random_access_iterator<_Iter1>) {
57	auto __ret = std::__search_n_random_access_impl<_RangeAlgPolicy>(	57	auto __ret =
58	__first, __last, __count, __value, __pred, __proj, __size);	58	std::__search_n_random_access_impl<_RangeAlgPolicy>(__first, __count, __value, __pred, __proj, __size);
59	return {std::move(__ret.first), std::move(__ret.second)};	59	return {std::move(__ret.first), std::move(__ret.second)};
60	}	60	}
61	}	61	}

lib/libcxx/include/__algorithm/rotate.h+27-44

...	@@ -12,16 +12,13 @@	...	@@ -12,16 +12,13 @@
12	#include <__algorithm/copy.h>	12	#include <__algorithm/copy.h>
13	#include <__algorithm/copy_backward.h>	13	#include <__algorithm/copy_backward.h>
14	#include <__algorithm/iterator_operations.h>	14	#include <__algorithm/iterator_operations.h>
		15	#include <__algorithm/min.h>
15	#include <__algorithm/move.h>	16	#include <__algorithm/move.h>
16	#include <__algorithm/move_backward.h>	17	#include <__algorithm/move_backward.h>
17	#include <__algorithm/swap_ranges.h>	18	#include <__algorithm/swap_ranges.h>
18	#include <__config>	19	#include <__config>
19	#include <__cstddef/size_t.h>
20	#include <__fwd/bit_reference.h>	20	#include <__fwd/bit_reference.h>
21	#include <__iterator/iterator_traits.h>	21	#include <__iterator/iterator_traits.h>
22	#include <__memory/construct_at.h>
23	#include <__memory/pointer_traits.h>
24	#include <__type_traits/is_constant_evaluated.h>
25	#include <__type_traits/is_trivially_assignable.h>	22	#include <__type_traits/is_trivially_assignable.h>
26	#include <__utility/move.h>	23	#include <__utility/move.h>
27	#include <__utility/pair.h>	24	#include <__utility/pair.h>
...	@@ -89,46 +86,32 @@ __rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIt	...	@@ -89,46 +86,32 @@ __rotate_forward(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIt
89	return __r;	86	return __r;
90	}	87	}
91		88
92	template <typename _Integral>	89	template <class _AlgPolicy, class _Iter, class _Sent>
93	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Integral __algo_gcd(_Integral __x, _Integral __y) {	90	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _Iter
94	do {	91	__rotate_random_access(_Iter __first, _Iter __middle, _Sent __sent) {
95	_Integral __t = __x % __y;	92	auto __left = _IterOps<_AlgPolicy>::distance(__first, __middle);
96	__x = __y;	93	auto __right = _IterOps<_AlgPolicy>::distance(__middle, __sent);
97	__y = __t;	94	auto __last = __first + __right;
98	} while (__y);	95
99	return __x;	96	auto __min_len = std::min(__left, __right);
100	}	97
101		98	while (__min_len > 0) {
102	template <class _AlgPolicy, typename _RandomAccessIterator>	99	if (__left <= __right) {
103	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 _RandomAccessIterator	100	do {
104	__rotate_gcd(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last) {	101	std::__swap_ranges<_AlgPolicy>(__first, __first + __left, __first + __left);
105	typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;	102	__first += __left;
106	typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;	103	__right -= __left;
107	using _Ops = _IterOps<_AlgPolicy>;	104	} while (__left <= __right);
108		105	__min_len = __right;
109	const difference_type __m1 = __middle - __first;	106	} else {
110	const difference_type __m2 = _Ops::distance(__middle, __last);	107	do {
111	if (__m1 == __m2) {	108	std::__swap_ranges<_AlgPolicy>(__first + (__left - __right), __first + __left, __first + __left);
112	std::__swap_ranges<_AlgPolicy>(__first, __middle, __middle, __last);	109	__left -= __right;
113	return __middle;	110	} while (__left > __right);
114	}	111	__min_len = __left;
115	const difference_type __g = std::__algo_gcd(__m1, __m2);	112	}
116	for (_RandomAccessIterator __p = __first + __g; __p != __first;) {
117	value_type __t(_Ops::__iter_move(--__p));
118	_RandomAccessIterator __p1 = __p;
119	_RandomAccessIterator __p2 = __p1 + __m1;
120	do {
121	*__p1 = _Ops::__iter_move(__p2);
122	__p1 = __p2;
123	const difference_type __d = _Ops::distance(__p2, __last);
124	if (__m1 < __d)
125	__p2 += __m1;
126	else
127	__p2 = __first + (__m1 - __d);
128	} while (__p2 != __p);
129	*__p1 = std::move(__t);
130	}	113	}
131	return __first + __m2;	114	return __last;
132	}	115	}
133		116
134	template <class _AlgPolicy, class _ForwardIterator>	117	template <class _AlgPolicy, class _ForwardIterator>
...	@@ -170,7 +153,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _RandomAccessIterator	...	@@ -170,7 +153,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _RandomAccessIterator
170	return std::__rotate_left<_AlgPolicy>(__first, __last);	153	return std::__rotate_left<_AlgPolicy>(__first, __last);
171	if (_IterOps<_AlgPolicy>::next(__middle) == __last)	154	if (_IterOps<_AlgPolicy>::next(__middle) == __last)
172	return std::__rotate_right<_AlgPolicy>(__first, __last);	155	return std::__rotate_right<_AlgPolicy>(__first, __last);
173	return std::__rotate_gcd<_AlgPolicy>(__first, __middle, __last);	156	return std::__rotate_random_access<_AlgPolicy>(__first, __middle, __last);
174	}	157	}
175	return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);	158	return std::__rotate_forward<_AlgPolicy>(__first, __middle, __last);
176	}	159	}

lib/libcxx/include/__algorithm/search_n.h+49-37

...	@@ -14,11 +14,7 @@	...	@@ -14,11 +14,7 @@
14	#include <__algorithm/iterator_operations.h>	14	#include <__algorithm/iterator_operations.h>
15	#include <__config>	15	#include <__config>
16	#include <__functional/identity.h>	16	#include <__functional/identity.h>
17	#include <__iterator/advance.h>
18	#include <__iterator/concepts.h>
19	#include <__iterator/distance.h>
20	#include <__iterator/iterator_traits.h>	17	#include <__iterator/iterator_traits.h>
21	#include <__ranges/concepts.h>
22	#include <__type_traits/enable_if.h>	18	#include <__type_traits/enable_if.h>
23	#include <__type_traits/invoke.h>	19	#include <__type_traits/invoke.h>
24	#include <__type_traits/is_callable.h>	20	#include <__type_traits/is_callable.h>
...	@@ -68,44 +64,60 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter> __search_	...	@@ -68,44 +64,60 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter> __search_
68	}	64	}
69	}	65	}
70		66
71	template <class _AlgPolicy, class _Pred, class _Iter, class _Sent, class _SizeT, class _Type, class _Proj, class _DiffT>	67	// Finds the longest suffix in [__first, __last) where each element satisfies __pred.
		68	template <class _RAIter, class _Pred, class _Proj, class _ValueT>
		69	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _RAIter
		70	__find_longest_suffix(_RAIter __first, _RAIter __last, const _ValueT& __value, _Pred& __pred, _Proj& __proj) {
		71	while (__first != __last) {
		72	if (!std::__invoke(__pred, std::__invoke(__proj, *--__last), __value)) {
		73	return ++__last;
		74	}
		75	}
		76	return __first;
		77	}
		78
		79	template <class _AlgPolicy, class _Pred, class _Iter, class _SizeT, class _Type, class _Proj, class _DiffT>
72	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 std::pair<_Iter, _Iter> __search_n_random_access_impl(	80	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 std::pair<_Iter, _Iter> __search_n_random_access_impl(
73	_Iter __first, _Sent __last, _SizeT __count, const _Type& __value, _Pred& __pred, _Proj& __proj, _DiffT __size1) {	81	_Iter __first, _SizeT __count_in, const _Type& __value, _Pred& __pred, _Proj& __proj, _DiffT __size) {
74	using difference_type = typename iterator_traits<_Iter>::difference_type;	82	auto __last = __first + __size;
		83	auto __count = static_cast<_DiffT>(__count_in);
		84
75	if (__count == 0)	85	if (__count == 0)
76	return std::make_pair(__first, __first);	86	return std::make_pair(__first, __first);
77	if (__size1 < static_cast<_DiffT>(__count)) {	87	if (__size < __count)
78	_IterOps<_AlgPolicy>::__advance_to(__first, __last);	88	return std::make_pair(__last, __last);
79	return std::make_pair(__first, __first);	89
80	}	90	// [__match_start, __match_start + __count) is the subrange which we currently check whether it only contains matching
		91	// elements. This subrange is returned in case all the elements match.
		92	// [__match_start, __matched_until) is the longest subrange where all elements are known to match at any given point
		93	// in time.
		94	// [__matched_until, __match_start + __count) is the subrange where we don't know whether the elements match.
		95
		96	// This algorithm tries to expand the subrange [__match_start, __matched_until) into a range of sufficient length.
		97	// When we fail to do that because we find a mismatching element, we move it forward to the beginning of the next
		98	// consecutive sequence that is not known not to match.
		99
		100	const _Iter __try_match_until = __last - __count;
		101	_Iter __match_start = __first;
		102	_Iter __matched_until = __first;
81		103
82	const auto __s = __first + __size1 - difference_type(__count - 1); // Start of pattern match can't go beyond here
83	while (true) {	104	while (true) {
84	// Find first element in sequence that matchs __value, with a mininum of loop checks	105	// There's no chance of expanding the subrange into a sequence of sufficient length, since we don't have enough
85	while (true) {	106	// elements in the haystack anymore.
86	if (__first >= __s) { // return __last if no element matches __value	107	if (__match_start > __try_match_until)
87	_IterOps<_AlgPolicy>::__advance_to(__first, __last);	108	return std::make_pair(__last, __last);
88	return std::make_pair(__first, __first);
89	}
90	if (std::__invoke(__pred, std::__invoke(__proj, *__first), __value))
91	break;
92	++__first;
93	}
94	// *__first matches __value_, now match elements after here
95	auto __m = __first;
96	_SizeT __c(0);
97	while (true) {
98	if (++__c == __count) // If pattern exhausted, __first is the answer (works for 1 element pattern)
99	return std::make_pair(__first, __first + _DiffT(__count));
100	++__m; // no need to check range on __m because __s guarantees we have enough source
101		109
102	// if there is a mismatch, restart with a new __first	110	auto __mismatch = std::__find_longest_suffix(__matched_until, __match_start + __count, __value, __pred, __proj);
103	if (!std::__invoke(__pred, std::__invoke(__proj, *__m), __value)) {	111
104	__first = __m;	112	// If all elements in [__matched_until, __match_start + __count) match, we know that
105	++__first;	113	// [__match_start, __match_start + __count) is a full sequence of matching elements, so we're done.
106	break;	114	if (__mismatch == __matched_until)
107	} // else there is a match, check next elements	115	return std::make_pair(__match_start, __match_start + __count);
108	}	116
		117	// Otherwise, we have to move the [__match_start, __matched_until) subrange forward past the point where we know for
		118	// sure a match is impossible.
		119	__matched_until = __match_start + __count;
		120	__match_start = __mismatch;
109	}	121	}
110	}	122	}
111		123
...	@@ -119,7 +131,7 @@ template <class _Iter,	...	@@ -119,7 +131,7 @@ template <class _Iter,
119	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter>	131	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<_Iter, _Iter>
120	__search_n_impl(_Iter __first, _Sent __last, _DiffT __count, const _Type& __value, _Pred& __pred, _Proj& __proj) {	132	__search_n_impl(_Iter __first, _Sent __last, _DiffT __count, const _Type& __value, _Pred& __pred, _Proj& __proj) {
121	return std::__search_n_random_access_impl<_ClassicAlgPolicy>(	133	return std::__search_n_random_access_impl<_ClassicAlgPolicy>(
122	__first, __last, __count, __value, __pred, __proj, __last - __first);	134	__first, __count, __value, __pred, __proj, __last - __first);
123	}	135	}
124		136
125	template <class _Iter1,	137	template <class _Iter1,

lib/libcxx/include/__algorithm/sift_down.h+19-18

 @@ -24,59 +24,60 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>
+template <class _AlgPolicy, bool __assume_both_children, class _Compare, class _RandomAccessIterator>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
 __sift_down(_RandomAccessIterator __first,
             _Compare&& __comp,
-            typename iterator_traits<_RandomAccessIterator>::difference_type __len,
+            __iterator_difference_type<_RandomAccessIterator> __len,
-            _RandomAccessIterator __start) {
+            __iterator_difference_type<_RandomAccessIterator> __start) {
   using _Ops = _IterOps<_AlgPolicy>;
   typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
   typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
   // left-child of __start is at 2 * __start + 1
   // right-child of __start is at 2 * __start + 2
-  difference_type __child = __start - __first;
+  difference_type __child = __start;
   if (__len < 2 || (__len - 2) / 2 < __child)
     return;
-  __child                         = 2 * __child + 1;
+  __child = 2 * __child + 1;
-  _RandomAccessIterator __child_i = __first + __child;
-  if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
+  if _LIBCPP_CONSTEXPR (__assume_both_children) {
+    // right-child exists and is greater than left-child
+    __child += __comp(__first[__child], __first[__child + 1]);
+  } else if ((__child + 1) < __len && __comp(__first[__child], __first[__child + 1])) {
     // right-child exists and is greater than left-child
-    ++__child_i;
     ++__child;
   }
   // check if we are in heap-order
-  if (__comp(*__child_i, *__start))
+  if (__comp(__first[__child], __first[__start]))
     // we are, __start is larger than its largest child
     return;
-  value_type __top(_Ops::__iter_move(__start));
+  value_type __top(_Ops::__iter_move(__first + __start));
   do {
     // we are not in heap-order, swap the parent with its largest child
-    *__start = _Ops::__iter_move(__child_i);
+    __first[__start] = _Ops::__iter_move(__first + __child);
-    __start  = __child_i;
+    __start          = __child;
     if ((__len - 2) / 2 < __child)
       break;
     // recompute the child based off of the updated parent
-    __child   = 2 * __child + 1;
+    __child = 2 * __child + 1;
-    __child_i = __first + __child;
-    if ((__child + 1) < __len && __comp(*__child_i, *(__child_i + difference_type(1)))) {
+    if _LIBCPP_CONSTEXPR (__assume_both_children) {
+      __child += __comp(__first[__child], __first[__child + 1]);
+    } else if ((__child + 1) < __len && __comp(__first[__child], __first[__child + 1])) {
       // right-child exists and is greater than left-child
-      ++__child_i;
       ++__child;
     }
     // check if we are in heap-order
-  } while (!__comp(*__child_i, __top));
+  } while (!__comp(__first[__child], __top));
-  *__start = std::move(__top);
+  __first[__start] = std::move(__top);
 }
 template <class _AlgPolicy, class _Compare, class _RandomAccessIterator>

lib/libcxx/include/__algorithm/simd_utils.h+33-4

...	@@ -26,9 +26,7 @@ _LIBCPP_PUSH_MACROS	...	@@ -26,9 +26,7 @@ _LIBCPP_PUSH_MACROS
26	#include <__undef_macros>	26	#include <__undef_macros>
27		27
28	// TODO: Find out how altivec changes things and allow vectorizations there too.	28	// TODO: Find out how altivec changes things and allow vectorizations there too.
29	// TODO: Simplify this condition once we stop building with AppleClang 15 in the CI.	29	#if _LIBCPP_STD_VER >= 14 && defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(__ALTIVEC__)
30	#if _LIBCPP_STD_VER >= 14 && defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(__ALTIVEC__) && \
31	!(defined(_LIBCPP_APPLE_CLANG_VER) && _LIBCPP_APPLE_CLANG_VER < 1600)
32	# define _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS 1	30	# define _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS 1
33	#else	31	#else
34	# define _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS 0	32	# define _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS 0
...	@@ -116,16 +114,47 @@ template <class _VecT, class _Iter>	...	@@ -116,16 +114,47 @@ template <class _VecT, class _Iter>
116	}(make_index_sequence<__simd_vector_size_v<_VecT>>{});	114	}(make_index_sequence<__simd_vector_size_v<_VecT>>{});
117	}	115	}
118		116
		117	// Load the first _Np elements, zero the rest
		118	_LIBCPP_DIAGNOSTIC_PUSH
		119	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wpsabi")
		120	template <class _VecT, size_t _Np, class _Iter>
		121	[[__nodiscard__]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _VecT __partial_load(_Iter __iter) noexcept {
		122	return [=]<size_t... _LoadIndices, size_t... _ZeroIndices>(
		123	index_sequence<_LoadIndices...>, index_sequence<_ZeroIndices...>) _LIBCPP_ALWAYS_INLINE noexcept {
		124	return _VecT{__iter[_LoadIndices]..., ((void)_ZeroIndices, 0)...};
		125	}(make_index_sequence<_Np>{}, make_index_sequence<__simd_vector_size_v<_VecT> - _Np>{});
		126	}
		127
		128	// Create a vector where every elements is __val
		129	template <class _VecT>
		130	[[__nodiscard__]] _LIBCPP_ALWAYS_INLINE _LIBCPP_HIDE_FROM_ABI _VecT
		131	__broadcast(__simd_vector_underlying_type_t<_VecT> __val) {
		132	return [&]<std::size_t... _Indices>(index_sequence<_Indices...>) {
		133	return _VecT{((void)_Indices, __val)...};
		134	}(make_index_sequence<__simd_vector_size_v<_VecT>>());
		135	}
		136	_LIBCPP_DIAGNOSTIC_POP
		137
		138	template <class _Tp, size_t _Np>
		139	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool __any_of(__simd_vector<_Tp, _Np> __vec) noexcept {
		140	return __builtin_reduce_or(__builtin_convertvector(__vec, __simd_vector<bool, _Np>));
		141	}
		142
119	template <class _Tp, size_t _Np>	143	template <class _Tp, size_t _Np>
120	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool __all_of(__simd_vector<_Tp, _Np> __vec) noexcept {	144	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool __all_of(__simd_vector<_Tp, _Np> __vec) noexcept {
121	return __builtin_reduce_and(__builtin_convertvector(__vec, __simd_vector<bool, _Np>));	145	return __builtin_reduce_and(__builtin_convertvector(__vec, __simd_vector<bool, _Np>));
122	}	146	}
123		147
		148	template <class _Tp, size_t _Np>
		149	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool __none_of(__simd_vector<_Tp, _Np> __vec) noexcept {
		150	return !__builtin_reduce_or(__builtin_convertvector(__vec, __simd_vector<bool, _Np>));
		151	}
		152
124	template <class _Tp, size_t _Np>	153	template <class _Tp, size_t _Np>
125	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t __find_first_set(__simd_vector<_Tp, _Np> __vec) noexcept {	154	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t __find_first_set(__simd_vector<_Tp, _Np> __vec) noexcept {
126	using __mask_vec = __simd_vector<bool, _Np>;	155	using __mask_vec = __simd_vector<bool, _Np>;
127		156
128	// This has MSan disabled du to https://github.com/llvm/llvm-project/issues/85876	157	// This has MSan disabled du to https://llvm.org/PR85876
129	auto __impl = [&]<class _MaskT>(_MaskT) _LIBCPP_NO_SANITIZE("memory") noexcept {	158	auto __impl = [&]<class _MaskT>(_MaskT) _LIBCPP_NO_SANITIZE("memory") noexcept {
130	# if defined(_LIBCPP_BIG_ENDIAN)	159	# if defined(_LIBCPP_BIG_ENDIAN)
131	return std::min<size_t>(	160	return std::min<size_t>(

lib/libcxx/include/__algorithm/specialized_algorithms.h created+54

...	@@ -0,0 +1,54 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___ALGORITHM_SPECIALIZED_ALGORITHMS_H
10	#define _LIBCPP___ALGORITHM_SPECIALIZED_ALGORITHMS_H
11
12	#include <__config>
13
14	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15	# pragma GCC system_header
16	#endif
17
18	_LIBCPP_BEGIN_NAMESPACE_STD
19
20	namespace _Algorithm {
21	struct __copy {};
22	struct __fill_n {};
23	struct __for_each {};
24	} // namespace _Algorithm
25
26	template <class>
27	struct __single_iterator;
28
29	template <class, class>
30	struct __iterator_pair;
31
32	template <class>
33	struct __single_range;
34
35	// This struct allows specializing algorithms for specific arguments. This is useful when we know a more efficient
36	// algorithm implementation for e.g. library-defined iterators. _Alg is one of tags defined inside the _Algorithm
37	// namespace above. _Ranges is an essentially arbitrary subset of the arguments to the algorithm that are used for
38	// dispatching. This set is specific to the algorithm: look at each algorithm to see which arguments they use for
39	// dispatching to specialized algorithms.
40	//
41	// A specialization of `__specialized_algorithm` has to define `__has_algorithm` to true for the specialized algorithm
42	// to be used. This is intended for cases where iterators can do generic unwrapping and forward to a different
43	// specialization of `__specialized_algorithm`.
44	//
45	// If __has_algorithm is true, there has to be an operator() which will get called with the actual arguments to the
46	// algorithm.
47	template <class _Alg, class... _Ranges>
48	struct __specialized_algorithm {
49	static const bool __has_algorithm = false;
50	};
51
52	_LIBCPP_END_NAMESPACE_STD
53
54	#endif // _LIBCPP___ALGORITHM_SPECIALIZED_ALGORITHMS_H

lib/libcxx/include/__algorithm/stable_sort.h+1-1

...	@@ -247,7 +247,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void __stable_sort(	...	@@ -247,7 +247,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void __stable_sort(
247	constexpr auto __default_comp = __desugars_to_v<__less_tag, _Compare, value_type, value_type >;	247	constexpr auto __default_comp = __desugars_to_v<__less_tag, _Compare, value_type, value_type >;
248	constexpr auto __radix_sortable =	248	constexpr auto __radix_sortable =
249	__is_ordered_integer_representable_v<value_type> &&	249	__is_ordered_integer_representable_v<value_type> &&
250	is_same_v< value_type&, __iter_reference<_RandomAccessIterator>>;	250	is_same_v< value_type&, __iterator_reference<_RandomAccessIterator>>;
251	if constexpr (__default_comp && __radix_sortable) {	251	if constexpr (__default_comp && __radix_sortable) {
252	if (__len <= __buff_size && __len >= static_cast<difference_type>(std::__radix_sort_min_bound<value_type>()) &&	252	if (__len <= __buff_size && __len >= static_cast<difference_type>(std::__radix_sort_min_bound<value_type>()) &&
253	__len <= static_cast<difference_type>(std::__radix_sort_max_bound<value_type>())) {	253	__len <= static_cast<difference_type>(std::__radix_sort_max_bound<value_type>())) {

lib/libcxx/include/__assertion_handler+31-4

...	@@ -16,6 +16,7 @@	...	@@ -16,6 +16,7 @@
16	# include <__cxx03/__verbose_trap>	16	# include <__cxx03/__verbose_trap>
17	#else	17	#else
18	# include <__config>	18	# include <__config>
		19	# include <__log_hardening_failure>
19	# include <__verbose_abort>	20	# include <__verbose_abort>
20	# include <__verbose_trap>	21	# include <__verbose_trap>
21	#endif	22	#endif
...	@@ -24,14 +25,40 @@	...	@@ -24,14 +25,40 @@
24	# pragma GCC system_header	25	# pragma GCC system_header
25	#endif	26	#endif
26		27
27	#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG	28	#if __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
28		29
29	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_ABORT("%s", message)	30	// Keep the old implementation that doesn't support assertion semantics for backward compatibility with the frozen C++03
		31	// mode.
		32	# if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
		33	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_ABORT("%s", message)
		34	# else
		35	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_TRAP(message)
		36	# endif // _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
30		37
31	#else	38	#else
32		39
33	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_TRAP(message)	40	# if _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_IGNORE
		41	# define _LIBCPP_ASSERTION_HANDLER(message) ((void)0)
		42
		43	# elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_OBSERVE
		44	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_LOG_HARDENING_FAILURE(message)
		45
		46	# elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE
		47	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_TRAP(message)
		48
		49	# elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_ENFORCE
		50	# define _LIBCPP_ASSERTION_HANDLER(message) _LIBCPP_VERBOSE_ABORT("%s", message)
		51
		52	# else
		53
		54	# error _LIBCPP_ASSERTION_SEMANTIC must be set to one of the following values: \
		55	_LIBCPP_ASSERTION_SEMANTIC_IGNORE, \
		56	_LIBCPP_ASSERTION_SEMANTIC_OBSERVE, \
		57	_LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE, \
		58	_LIBCPP_ASSERTION_SEMANTIC_ENFORCE
		59
		60	# endif // _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_IGNORE
34		61
35	#endif // _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG	62	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
36		63
37	#endif // _LIBCPP___ASSERTION_HANDLER	64	#endif // _LIBCPP___ASSERTION_HANDLER

lib/libcxx/include/__atomic/atomic.h+36-60

 @@ -10,7 +10,9 @@
 #define _LIBCPP___ATOMIC_ATOMIC_H
 #include <__atomic/atomic_sync.h>
+#include <__atomic/atomic_waitable_traits.h>
 #include <__atomic/check_memory_order.h>
+#include <__atomic/floating_point_helper.h>
 #include <__atomic/is_always_lock_free.h>
 #include <__atomic/memory_order.h>
 #include <__atomic/support.h>
 @@ -47,10 +49,10 @@ struct __atomic_base // false
   static constexpr bool is_always_lock_free = __libcpp_is_always_lock_free<__cxx_atomic_impl<_Tp> >::__value;
 #endif
-  _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const volatile _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const volatile _NOEXCEPT {
     return __cxx_atomic_is_lock_free(sizeof(__cxx_atomic_impl<_Tp>));
   }
-  _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const _NOEXCEPT {
     return static_cast<__atomic_base const volatile*>(this)->is_lock_free();
   }
   _LIBCPP_HIDE_FROM_ABI void store(_Tp __d, memory_order __m = memory_order_seq_cst) volatile _NOEXCEPT
 @@ -61,11 +63,11 @@ struct __atomic_base // false
       _LIBCPP_CHECK_STORE_MEMORY_ORDER(__m) {
     std::__cxx_atomic_store(std::addressof(__a_), __d, __m);
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT
       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
     return std::__cxx_atomic_load(std::addressof(__a_), __m);
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __m = memory_order_seq_cst) const _NOEXCEPT
       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
     return std::__cxx_atomic_load(std::addressof(__a_), __m);
   }
 @@ -113,22 +115,16 @@ struct __atomic_base // false
   }
 #if _LIBCPP_STD_VER >= 20
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const
+  _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT {
-      volatile _NOEXCEPT {
     std::__atomic_wait(*this, __v, __m);
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+  _LIBCPP_HIDE_FROM_ABI void wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
-  wait(_Tp __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
     std::__atomic_wait(*this, __v, __m);
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT { std::__atomic_notify_one(*this); }
-    std::__atomic_notify_one(*this);
+  _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT { std::__atomic_notify_one(*this); }
-  }
+  _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT { std::__atomic_notify_all(*this); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT { std::__atomic_notify_one(*this); }
+  _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT { std::__atomic_notify_all(*this); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
-    std::__atomic_notify_all(*this);
-  }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT { std::__atomic_notify_all(*this); }
 #endif //  _LIBCPP_STD_VER >= 20
 #if _LIBCPP_STD_VER >= 20
 @@ -205,12 +201,15 @@ struct __atomic_base<_Tp, true> : public __atomic_base<_Tp, false> {
   _LIBCPP_HIDE_FROM_ABI _Tp operator^=(_Tp __op) _NOEXCEPT { return fetch_xor(__op) ^ __op; }
 };
+#if _LIBCPP_STD_VER >= 20
 // Here we need _IsIntegral because the default template argument is not enough
 // e.g  __atomic_base<int> is __atomic_base<int, true>, which inherits from
 // __atomic_base<int, false> and the caller of the wait function is
 // __atomic_base<int, false>. So specializing __atomic_base<_Tp> does not work
 template <class _Tp, bool _IsIntegral>
 struct __atomic_waitable_traits<__atomic_base<_Tp, _IsIntegral> > {
+  using __value_type _LIBCPP_NODEBUG = _Tp;
   static _LIBCPP_HIDE_FROM_ABI _Tp __atomic_load(const __atomic_base<_Tp, _IsIntegral>& __a, memory_order __order) {
     return __a.load(__order);
   }
 @@ -231,6 +230,8 @@ struct __atomic_waitable_traits<__atomic_base<_Tp, _IsIntegral> > {
   }
 };
+#endif // _LIBCPP_STD_VER >= 20
 template <typename _Tp>
 struct __check_atomic_mandates {
   using type _LIBCPP_NODEBUG = _Tp;
 @@ -324,50 +325,26 @@ struct atomic<_Tp*> : public __atomic_base<_Tp*> {
   atomic& operator=(const atomic&) volatile = delete;
 };
+#if _LIBCPP_STD_VER >= 20
 template <class _Tp>
 struct __atomic_waitable_traits<atomic<_Tp> > : __atomic_waitable_traits<__atomic_base<_Tp> > {};
-#if _LIBCPP_STD_VER >= 20
 template <class _Tp>
   requires is_floating_point_v<_Tp>
 struct atomic<_Tp> : __atomic_base<_Tp> {
 private:
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool __is_fp80_long_double() {
-    // Only x87-fp80 long double has 64-bit mantissa
-    return __LDBL_MANT_DIG__ == 64 && std::is_same_v<_Tp, long double>;
-  }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool __has_rmw_builtin() {
-#  ifndef _LIBCPP_COMPILER_CLANG_BASED
-    return false;
-#  else
-    // The builtin __cxx_atomic_fetch_add errors during compilation for
-    // long double on platforms with fp80 format.
-    // For more details, see
-    // lib/Sema/SemaChecking.cpp function IsAllowedValueType
-    // LLVM Parser does not allow atomicrmw with x86_fp80 type.
-    // if (ValType->isSpecificBuiltinType(BuiltinType::LongDouble) &&
-    //    &Context.getTargetInfo().getLongDoubleFormat() ==
-    //        &llvm::APFloat::x87DoubleExtended())
-    // For more info
-    // https://github.com/llvm/llvm-project/issues/68602
-    // https://reviews.llvm.org/D53965
-    return !__is_fp80_long_double();
-#  endif
-  }
   template <class _This, class _Operation, class _BuiltinOp>
   _LIBCPP_HIDE_FROM_ABI static _Tp
   __rmw_op(_This&& __self, _Tp __operand, memory_order __m, _Operation __operation, _BuiltinOp __builtin_op) {
-    if constexpr (__has_rmw_builtin()) {
+    if constexpr (std::__has_rmw_builtin<_Tp>()) {
       return __builtin_op(std::addressof(std::forward<_This>(__self).__a_), __operand, __m);
     } else {
       _Tp __old = __self.load(memory_order_relaxed);
       _Tp __new = __operation(__old, __operand);
       while (!__self.compare_exchange_weak(__old, __new, __m, memory_order_relaxed)) {
 #  ifdef _LIBCPP_COMPILER_CLANG_BASED
-        if constexpr (__is_fp80_long_double()) {
+        if constexpr (std::__is_fp80_long_double<_Tp>()) {
-          // https://github.com/llvm/llvm-project/issues/47978
+          // https://llvm.org/PR47978
           // clang bug: __old is not updated on failure for atomic<long double>::compare_exchange_weak
           // Note __old = __self.load(memory_order_relaxed) will not work
           std::__cxx_atomic_load_inplace(std::addressof(__self.__a_), std::addressof(__old), memory_order_relaxed);
 @@ -462,12 +439,12 @@ public:
 // atomic_is_lock_free
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const volatile atomic<_Tp>* __o) _NOEXCEPT {
   return __o->is_lock_free();
 }
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const atomic<_Tp>* __o) _NOEXCEPT {
   return __o->is_lock_free();
 }
 @@ -516,25 +493,25 @@ atomic_store_explicit(atomic<_Tp>* __o, typename atomic<_Tp>::value_type __d, me
 // atomic_load
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp atomic_load(const volatile atomic<_Tp>* __o) _NOEXCEPT {
   return __o->load();
 }
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp atomic_load(const atomic<_Tp>* __o) _NOEXCEPT {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp atomic_load(const atomic<_Tp>* __o) _NOEXCEPT {
   return __o->load();
 }
 // atomic_load_explicit
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp
-    _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
+atomic_load_explicit(const volatile atomic<_Tp>* __o, memory_order __m) _NOEXCEPT _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
   return __o->load(__m);
 }
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI _Tp atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp atomic_load_explicit(const atomic<_Tp>* __o, memory_order __m) _NOEXCEPT
     _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
   return __o->load(__m);
 }
 @@ -642,28 +619,27 @@ _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong_explicit(
 // atomic_wait
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+_LIBCPP_HIDE_FROM_ABI void
 atomic_wait(const volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v) _NOEXCEPT {
   return __o->wait(__v);
 }
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+_LIBCPP_HIDE_FROM_ABI void atomic_wait(const atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v) _NOEXCEPT {
-atomic_wait(const atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v) _NOEXCEPT {
   return __o->wait(__v);
 }
 // atomic_wait_explicit
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+_LIBCPP_HIDE_FROM_ABI void
 atomic_wait_explicit(const volatile atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v, memory_order __m) _NOEXCEPT
     _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
   return __o->wait(__v, __m);
 }
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+_LIBCPP_HIDE_FROM_ABI void
 atomic_wait_explicit(const atomic<_Tp>* __o, typename atomic<_Tp>::value_type __v, memory_order __m) _NOEXCEPT
     _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__m) {
   return __o->wait(__v, __m);
 @@ -672,22 +648,22 @@ atomic_wait_explicit(const atomic<_Tp>* __o, typename atomic<_Tp>::value_type __
 // atomic_notify_one
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void atomic_notify_one(volatile atomic<_Tp>* __o) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI void atomic_notify_one(volatile atomic<_Tp>* __o) _NOEXCEPT {
   __o->notify_one();
 }
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void atomic_notify_one(atomic<_Tp>* __o) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI void atomic_notify_one(atomic<_Tp>* __o) _NOEXCEPT {
   __o->notify_one();
 }
 // atomic_notify_all
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void atomic_notify_all(volatile atomic<_Tp>* __o) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI void atomic_notify_all(volatile atomic<_Tp>* __o) _NOEXCEPT {
   __o->notify_all();
 }
 template <class _Tp>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void atomic_notify_all(atomic<_Tp>* __o) _NOEXCEPT {
+_LIBCPP_HIDE_FROM_ABI void atomic_notify_all(atomic<_Tp>* __o) _NOEXCEPT {
   __o->notify_all();
 }

lib/libcxx/include/__atomic/atomic_flag.h+19-37

 @@ -10,6 +10,7 @@
 #define _LIBCPP___ATOMIC_ATOMIC_FLAG_H
 #include <__atomic/atomic_sync.h>
+#include <__atomic/atomic_waitable_traits.h>
 #include <__atomic/contention_t.h>
 #include <__atomic/memory_order.h>
 #include <__atomic/support.h>
 @@ -49,22 +50,16 @@ struct atomic_flag {
   }
 #if _LIBCPP_STD_VER >= 20
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(bool __v, memory_order __m = memory_order_seq_cst) const
+  _LIBCPP_HIDE_FROM_ABI void wait(bool __v, memory_order __m = memory_order_seq_cst) const volatile _NOEXCEPT {
-      volatile _NOEXCEPT {
     std::__atomic_wait(*this, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void
+  _LIBCPP_HIDE_FROM_ABI void wait(bool __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
-  wait(bool __v, memory_order __m = memory_order_seq_cst) const _NOEXCEPT {
     std::__atomic_wait(*this, _LIBCPP_ATOMIC_FLAG_TYPE(__v), __m);
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void notify_one() volatile _NOEXCEPT { std::__atomic_notify_one(*this); }
-    std::__atomic_notify_one(*this);
+  _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT { std::__atomic_notify_one(*this); }
-  }
+  _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT { std::__atomic_notify_all(*this); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_one() _NOEXCEPT { std::__atomic_notify_one(*this); }
+  _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT { std::__atomic_notify_all(*this); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() volatile _NOEXCEPT {
-    std::__atomic_notify_all(*this);
-  }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void notify_all() _NOEXCEPT { std::__atomic_notify_all(*this); }
 #endif
 #if _LIBCPP_STD_VER >= 20
 @@ -80,8 +75,11 @@ struct atomic_flag {
   atomic_flag& operator=(const atomic_flag&) volatile = delete;
 };
+#if _LIBCPP_STD_VER >= 20
 template <>
 struct __atomic_waitable_traits<atomic_flag> {
+  using __value_type _LIBCPP_NODEBUG = _LIBCPP_ATOMIC_FLAG_TYPE;
   static _LIBCPP_HIDE_FROM_ABI _LIBCPP_ATOMIC_FLAG_TYPE __atomic_load(const atomic_flag& __a, memory_order __order) {
     return std::__cxx_atomic_load(&__a.__a_, __order);
   }
 @@ -101,6 +99,7 @@ struct __atomic_waitable_traits<atomic_flag> {
     return std::addressof(__a.__a_);
   }
 };
+#endif // _LIBCPP_STD_VER >= 20
 inline _LIBCPP_HIDE_FROM_ABI bool atomic_flag_test(const volatile atomic_flag* __o) _NOEXCEPT { return __o->test(); }
 @@ -143,43 +142,26 @@ inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_clear_explicit(atomic_flag* __o, m
 }
 #if _LIBCPP_STD_VER >= 20
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_wait(const volatile atomic_flag* __o, bool __v) _NOEXCEPT {
-atomic_flag_wait(const volatile atomic_flag* __o, bool __v) _NOEXCEPT {
   __o->wait(__v);
 }
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_wait(const atomic_flag* __o, bool __v) _NOEXCEPT { __o->wait(__v); }
-atomic_flag_wait(const atomic_flag* __o, bool __v) _NOEXCEPT {
-  __o->wait(__v);
-}
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+inline _LIBCPP_HIDE_FROM_ABI void
 atomic_flag_wait_explicit(const volatile atomic_flag* __o, bool __v, memory_order __m) _NOEXCEPT {
   __o->wait(__v, __m);
 }
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+inline _LIBCPP_HIDE_FROM_ABI void
 atomic_flag_wait_explicit(const atomic_flag* __o, bool __v, memory_order __m) _NOEXCEPT {
   __o->wait(__v, __m);
 }
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_notify_one(volatile atomic_flag* __o) _NOEXCEPT { __o->notify_one(); }
-atomic_flag_notify_one(volatile atomic_flag* __o) _NOEXCEPT {
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_notify_one(atomic_flag* __o) _NOEXCEPT { __o->notify_one(); }
-  __o->notify_one();
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_notify_all(volatile atomic_flag* __o) _NOEXCEPT { __o->notify_all(); }
-}
+inline _LIBCPP_HIDE_FROM_ABI void atomic_flag_notify_all(atomic_flag* __o) _NOEXCEPT { __o->notify_all(); }
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void atomic_flag_notify_one(atomic_flag* __o) _NOEXCEPT {
-  __o->notify_one();
-}
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void
-atomic_flag_notify_all(volatile atomic_flag* __o) _NOEXCEPT {
-  __o->notify_all();
-}
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_SYNC void atomic_flag_notify_all(atomic_flag* __o) _NOEXCEPT {
-  __o->notify_all();
-}
 #endif // _LIBCPP_STD_VER >= 20
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__atomic/atomic_ref.h+29-12

 @@ -19,7 +19,9 @@
 #include <__assert>
 #include <__atomic/atomic_sync.h>
+#include <__atomic/atomic_waitable_traits.h>
 #include <__atomic/check_memory_order.h>
+#include <__atomic/floating_point_helper.h>
 #include <__atomic/memory_order.h>
 #include <__atomic/to_gcc_order.h>
 #include <__concepts/arithmetic.h>
 @@ -121,7 +123,9 @@ public:
   static constexpr bool is_always_lock_free =
       __atomic_always_lock_free(sizeof(_Tp), std::addressof(__get_aligner_instance<required_alignment>::__instance));
-  _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const noexcept { return __atomic_is_lock_free(sizeof(_Tp), __ptr_); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_lock_free() const noexcept {
+    return __atomic_is_lock_free(sizeof(_Tp), __ptr_);
+  }
   _LIBCPP_HIDE_FROM_ABI void store(_Tp __desired, memory_order __order = memory_order::seq_cst) const noexcept
       _LIBCPP_CHECK_STORE_MEMORY_ORDER(__order) {
 @@ -136,7 +140,7 @@ public:
     return __desired;
   }
-  _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __order = memory_order::seq_cst) const noexcept
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Tp load(memory_order __order = memory_order::seq_cst) const noexcept
       _LIBCPP_CHECK_LOAD_MEMORY_ORDER(__order) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __order == memory_order::relaxed || __order == memory_order::consume || __order == memory_order::acquire ||
 @@ -219,6 +223,9 @@ public:
   }
   _LIBCPP_HIDE_FROM_ABI void notify_one() const noexcept { std::__atomic_notify_one(*this); }
   _LIBCPP_HIDE_FROM_ABI void notify_all() const noexcept { std::__atomic_notify_all(*this); }
+#  if _LIBCPP_STD_VER >= 26
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* address() const noexcept { return __ptr_; }
+#  endif
 protected:
   using _Aligned_Tp [[__gnu__::__aligned__(required_alignment), __gnu__::__nodebug__]] = _Tp;
 @@ -229,6 +236,8 @@ protected:
 template <class _Tp>
 struct __atomic_waitable_traits<__atomic_ref_base<_Tp>> {
+  using __value_type _LIBCPP_NODEBUG = _Tp;
   static _LIBCPP_HIDE_FROM_ABI _Tp __atomic_load(const __atomic_ref_base<_Tp>& __a, memory_order __order) {
     return __a.load(__order);
   }
 @@ -322,20 +331,28 @@ struct atomic_ref<_Tp> : public __atomic_ref_base<_Tp> {
   atomic_ref& operator=(const atomic_ref&) = delete;
   _LIBCPP_HIDE_FROM_ABI _Tp fetch_add(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
-    _Tp __old = this->load(memory_order_relaxed);
+    if constexpr (std::__has_rmw_builtin<_Tp>()) {
-    _Tp __new = __old + __arg;
+      return __atomic_fetch_add(this->__ptr_, __arg, std::__to_gcc_order(__order));
-    while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
+    } else {
-      __new = __old + __arg;
+      _Tp __old = this->load(memory_order_relaxed);
+      _Tp __new = __old + __arg;
+      while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
+        __new = __old + __arg;
+      }
+      return __old;
     }
-    return __old;
   }
   _LIBCPP_HIDE_FROM_ABI _Tp fetch_sub(_Tp __arg, memory_order __order = memory_order_seq_cst) const noexcept {
-    _Tp __old = this->load(memory_order_relaxed);
+    if constexpr (std::__has_rmw_builtin<_Tp>()) {
-    _Tp __new = __old - __arg;
+      return __atomic_fetch_sub(this->__ptr_, __arg, std::__to_gcc_order(__order));
-    while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
+    } else {
-      __new = __old - __arg;
+      _Tp __old = this->load(memory_order_relaxed);
+      _Tp __new = __old - __arg;
+      while (!this->compare_exchange_weak(__old, __new, __order, memory_order_relaxed)) {
+        __new = __old - __arg;
+      }
+      return __old;
     }
-    return __old;
   }
   _LIBCPP_HIDE_FROM_ABI _Tp operator+=(_Tp __arg) const noexcept { return fetch_add(__arg) + __arg; }

lib/libcxx/include/__atomic/atomic_sync.h+127-55

...	@@ -9,6 +9,7 @@	...	@@ -9,6 +9,7 @@
9	#ifndef _LIBCPP___ATOMIC_ATOMIC_SYNC_H	9	#ifndef _LIBCPP___ATOMIC_ATOMIC_SYNC_H
10	#define _LIBCPP___ATOMIC_ATOMIC_SYNC_H	10	#define _LIBCPP___ATOMIC_ATOMIC_SYNC_H
11		11
		12	#include <__atomic/atomic_waitable_traits.h>
12	#include <__atomic/contention_t.h>	13	#include <__atomic/contention_t.h>
13	#include <__atomic/memory_order.h>	14	#include <__atomic/memory_order.h>
14	#include <__atomic/to_gcc_order.h>	15	#include <__atomic/to_gcc_order.h>
...	@@ -19,6 +20,7 @@	...	@@ -19,6 +20,7 @@
19	#include <__type_traits/conjunction.h>	20	#include <__type_traits/conjunction.h>
20	#include <__type_traits/decay.h>	21	#include <__type_traits/decay.h>
21	#include <__type_traits/invoke.h>	22	#include <__type_traits/invoke.h>
		23	#include <__type_traits/is_same.h>
22	#include <__type_traits/void_t.h>	24	#include <__type_traits/void_t.h>
23	#include <__utility/declval.h>	25	#include <__utility/declval.h>
24	#include <cstring>	26	#include <cstring>
...	@@ -29,50 +31,89 @@	...	@@ -29,50 +31,89 @@
29		31
30	_LIBCPP_BEGIN_NAMESPACE_STD	32	_LIBCPP_BEGIN_NAMESPACE_STD
31		33
32	// The customisation points to enable the following functions:
33	// - __atomic_wait
34	// - __atomic_wait_unless
35	// - __atomic_notify_one
36	// - __atomic_notify_all
37	// Note that std::atomic<T>::wait was back-ported to C++03
38	// The below implementations look ugly to support C++03
39	template <class _Tp, class = void>
40	struct __atomic_waitable_traits {
41	template <class _AtomicWaitable>
42	static void __atomic_load(_AtomicWaitable&&, memory_order) = delete;
43
44	template <class _AtomicWaitable>
45	static void __atomic_contention_address(_AtomicWaitable&&) = delete;
46	};
47
48	template <class _Tp, class = void>
49	struct __atomic_waitable : false_type {};
50
51	template <class _Tp>
52	struct __atomic_waitable< _Tp,
53	__void_t<decltype(__atomic_waitable_traits<__decay_t<_Tp> >::__atomic_load(
54	std::declval<const _Tp&>(), std::declval<memory_order>())),
55	decltype(__atomic_waitable_traits<__decay_t<_Tp> >::__atomic_contention_address(
56	std::declval<const _Tp&>()))> > : true_type {};
57
58	#if _LIBCPP_STD_VER >= 20	34	#if _LIBCPP_STD_VER >= 20
59	# if _LIBCPP_HAS_THREADS	35	# if _LIBCPP_HAS_THREADS
60		36
61	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile*) _NOEXCEPT;	37	# if !_LIBCPP_AVAILABILITY_HAS_NEW_SYNC
62	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile*) _NOEXCEPT;	38
63	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t	39	// old dylib interface kept for backwards compatibility
64	__libcpp_atomic_monitor(void const volatile*) _NOEXCEPT;	40	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile*) _NOEXCEPT;
65	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void	41	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile*) _NOEXCEPT;
66	__libcpp_atomic_wait(void const volatile*, __cxx_contention_t) _NOEXCEPT;	42	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(void const volatile*) _NOEXCEPT;
67		43	_LIBCPP_EXPORTED_FROM_ABI void __libcpp_atomic_wait(void const volatile*, __cxx_contention_t) _NOEXCEPT;
68	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void	44
69	__cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;	45	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;
70	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void	46	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;
71	__cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;	47	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
72	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
73	__libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;	48	__libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile*) _NOEXCEPT;
74	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void	49	_LIBCPP_EXPORTED_FROM_ABI void
75	__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile*, __cxx_contention_t) _NOEXCEPT;	50	__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile*, __cxx_contention_t) _NOEXCEPT;
		51	# endif // !_LIBCPP_AVAILABILITY_HAS_NEW_SYNC
		52
		53	// new dylib interface
		54
		55	// return the global contention state's current value for the address
		56	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
		57	__atomic_monitor_global(void const* __address) _NOEXCEPT;
		58
		59	// wait on the global contention state to be changed from the given value for the address
		60	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void
		61	__atomic_wait_global_table(void const* __address, __cxx_contention_t __monitor_value) _NOEXCEPT;
		62
		63	// notify one waiter waiting on the global contention state for the address
		64	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_one_global_table(void const*) _NOEXCEPT;
		65
		66	// notify all waiters waiting on the global contention state for the address
		67	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_all_global_table(void const*) _NOEXCEPT;
		68
		69	// wait on the address directly with the native platform wait
		70	template <std::size_t _Size>
		71	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void
		72	__atomic_wait_native(void const* __address, void const* __old_value) _NOEXCEPT;
		73
		74	// notify one waiter waiting on the address directly with the native platform wait
		75	template <std::size_t _Size>
		76	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_one_native(const void*) _NOEXCEPT;
		77
		78	// notify all waiters waiting on the address directly with the native platform wait
		79	template <std::size_t _Size>
		80	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_all_native(const void*) _NOEXCEPT;
		81
		82	# if _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
		83
		84	template <class _AtomicWaitable, class _Poll>
		85	struct __atomic_wait_backoff_impl {
		86	const _AtomicWaitable& __a_;
		87	_Poll __poll_;
		88	memory_order __order_;
		89
		90	using __waitable_traits _LIBCPP_NODEBUG = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;
		91	using __value_type _LIBCPP_NODEBUG = typename __waitable_traits::__value_type;
		92
		93	_LIBCPP_HIDE_FROM_ABI __backoff_results operator()(chrono::nanoseconds __elapsed) const {
		94	if (__elapsed > chrono::microseconds(4)) {
		95	auto __contention_address = const_cast<const void*>(
		96	static_cast<const volatile void*>(__waitable_traits::__atomic_contention_address(__a_)));
		97
		98	if constexpr (__has_native_atomic_wait<__value_type>) {
		99	auto __atomic_value = __waitable_traits::__atomic_load(__a_, __order_);
		100	if (__poll_(__atomic_value))
		101	return __backoff_results::__poll_success;
		102	std::__atomic_wait_native<sizeof(__value_type)>(__contention_address, std::addressof(__atomic_value));
		103	} else {
		104	__cxx_contention_t __monitor_val = std::__atomic_monitor_global(__contention_address);
		105	auto __atomic_value = __waitable_traits::__atomic_load(__a_, __order_);
		106	if (__poll_(__atomic_value))
		107	return __backoff_results::__poll_success;
		108	std::__atomic_wait_global_table(__contention_address, __monitor_val);
		109	}
		110	} else {
		111	} // poll
		112	return __backoff_results::__continue_poll;
		113	}
		114	};
		115
		116	# else // _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
76		117
77	template <class _AtomicWaitable, class _Poll>	118	template <class _AtomicWaitable, class _Poll>
78	struct __atomic_wait_backoff_impl {	119	struct __atomic_wait_backoff_impl {
...	@@ -82,7 +123,6 @@ struct __atomic_wait_backoff_impl {	...	@@ -82,7 +123,6 @@ struct __atomic_wait_backoff_impl {
82		123
83	using __waitable_traits _LIBCPP_NODEBUG = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;	124	using __waitable_traits _LIBCPP_NODEBUG = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;
84		125
85	_LIBCPP_AVAILABILITY_SYNC
86	_LIBCPP_HIDE_FROM_ABI bool	126	_LIBCPP_HIDE_FROM_ABI bool
87	__update_monitor_val_and_poll(__cxx_atomic_contention_t const volatile*, __cxx_contention_t& __monitor_val) const {	127	__update_monitor_val_and_poll(__cxx_atomic_contention_t const volatile*, __cxx_contention_t& __monitor_val) const {
88	// In case the contention type happens to be __cxx_atomic_contention_t, i.e. __cxx_atomic_impl<int64_t>,	128	// In case the contention type happens to be __cxx_atomic_contention_t, i.e. __cxx_atomic_impl<int64_t>,
...	@@ -95,7 +135,6 @@ struct __atomic_wait_backoff_impl {	...	@@ -95,7 +135,6 @@ struct __atomic_wait_backoff_impl {
95	return __poll_(__monitor_val);	135	return __poll_(__monitor_val);
96	}	136	}
97		137
98	_LIBCPP_AVAILABILITY_SYNC
99	_LIBCPP_HIDE_FROM_ABI bool	138	_LIBCPP_HIDE_FROM_ABI bool
100	__update_monitor_val_and_poll(void const volatile* __contention_address, __cxx_contention_t& __monitor_val) const {	139	__update_monitor_val_and_poll(void const volatile* __contention_address, __cxx_contention_t& __monitor_val) const {
101	// In case the contention type is anything else, platform wait is monitoring a __cxx_atomic_contention_t	140	// In case the contention type is anything else, platform wait is monitoring a __cxx_atomic_contention_t
...	@@ -105,20 +144,21 @@ struct __atomic_wait_backoff_impl {	...	@@ -105,20 +144,21 @@ struct __atomic_wait_backoff_impl {
105	return __poll_(__current_val);	144	return __poll_(__current_val);
106	}	145	}
107		146
108	_LIBCPP_AVAILABILITY_SYNC	147	_LIBCPP_HIDE_FROM_ABI __backoff_results operator()(chrono::nanoseconds __elapsed) const {
109	_LIBCPP_HIDE_FROM_ABI bool operator()(chrono::nanoseconds __elapsed) const {
110	if (__elapsed > chrono::microseconds(4)) {	148	if (__elapsed > chrono::microseconds(4)) {
111	auto __contention_address = __waitable_traits::__atomic_contention_address(__a_);	149	auto __contention_address = __waitable_traits::__atomic_contention_address(__a_);
112	__cxx_contention_t __monitor_val;	150	__cxx_contention_t __monitor_val;
113	if (__update_monitor_val_and_poll(__contention_address, __monitor_val))	151	if (__update_monitor_val_and_poll(__contention_address, __monitor_val))
114	return true;	152	return __backoff_results::__poll_success;
115	std::__libcpp_atomic_wait(__contention_address, __monitor_val);	153	std::__libcpp_atomic_wait(__contention_address, __monitor_val);
116	} else {	154	} else {
117	} // poll	155	} // poll
118	return false;	156	return __backoff_results::__continue_poll;
119	}	157	}
120	};	158	};
121		159
		160	# endif // _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
		161
122	// The semantics of this function are similar to `atomic`'s	162	// The semantics of this function are similar to `atomic`'s
123	// `.wait(T old, std::memory_order order)`, but instead of having a hardcoded	163	// `.wait(T old, std::memory_order order)`, but instead of having a hardcoded
124	// predicate (is the loaded value unequal to `old`?), the predicate function is	164	// predicate (is the loaded value unequal to `old`?), the predicate function is
...	@@ -128,9 +168,8 @@ struct __atomic_wait_backoff_impl {	...	@@ -128,9 +168,8 @@ struct __atomic_wait_backoff_impl {
128	// `false`, it must set the argument to its current understanding of the atomic	168	// `false`, it must set the argument to its current understanding of the atomic
129	// value. The predicate function must not return `false` spuriously.	169	// value. The predicate function must not return `false` spuriously.
130	template <class _AtomicWaitable, class _Poll>	170	template <class _AtomicWaitable, class _Poll>
131	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void	171	_LIBCPP_HIDE_FROM_ABI void __atomic_wait_unless(const _AtomicWaitable& __a, memory_order __order, _Poll&& __poll) {
132	__atomic_wait_unless(const _AtomicWaitable& __a, memory_order __order, _Poll&& __poll) {	172	static_assert(__atomic_waitable<_AtomicWaitable>);
133	static_assert(__atomic_waitable<_AtomicWaitable>::value, "");
134	__atomic_wait_backoff_impl<_AtomicWaitable, __decay_t<_Poll> > __backoff_fn = {__a, __poll, __order};	173	__atomic_wait_backoff_impl<_AtomicWaitable, __decay_t<_Poll> > __backoff_fn = {__a, __poll, __order};
135	std::__libcpp_thread_poll_with_backoff(	174	std::__libcpp_thread_poll_with_backoff(
136	/* poll */	175	/* poll */
...	@@ -141,18 +180,52 @@ __atomic_wait_unless(const _AtomicWaitable& __a, memory_order __order, _Poll&& _	...	@@ -141,18 +180,52 @@ __atomic_wait_unless(const _AtomicWaitable& __a, memory_order __order, _Poll&& _
141	/* backoff */ __backoff_fn);	180	/* backoff */ __backoff_fn);
142	}	181	}
143		182
		183	# if _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
		184
144	template <class _AtomicWaitable>	185	template <class _AtomicWaitable>
145	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void __atomic_notify_one(const _AtomicWaitable& __a) {	186	_LIBCPP_HIDE_FROM_ABI void __atomic_notify_one(const _AtomicWaitable& __a) {
146	static_assert(__atomic_waitable<_AtomicWaitable>::value, "");	187	static_assert(__atomic_waitable<_AtomicWaitable>);
		188	using __value_type _LIBCPP_NODEBUG = typename __atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__value_type;
		189	using __waitable_traits _LIBCPP_NODEBUG = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;
		190	auto __contention_address =
		191	const_cast<const void>(static_cast<const volatile void>(__waitable_traits::__atomic_contention_address(__a)));
		192	if constexpr (__has_native_atomic_wait<__value_type>) {
		193	std::__atomic_notify_one_native<sizeof(__value_type)>(__contention_address);
		194	} else {
		195	std::__atomic_notify_one_global_table(__contention_address);
		196	}
		197	}
		198
		199	template <class _AtomicWaitable>
		200	_LIBCPP_HIDE_FROM_ABI void __atomic_notify_all(const _AtomicWaitable& __a) {
		201	static_assert(__atomic_waitable<_AtomicWaitable>);
		202	using __value_type _LIBCPP_NODEBUG = typename __atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__value_type;
		203	using __waitable_traits _LIBCPP_NODEBUG = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;
		204	auto __contention_address =
		205	const_cast<const void>(static_cast<const volatile void>(__waitable_traits::__atomic_contention_address(__a)));
		206	if constexpr (__has_native_atomic_wait<__value_type>) {
		207	std::__atomic_notify_all_native<sizeof(__value_type)>(__contention_address);
		208	} else {
		209	std::__atomic_notify_all_global_table(__contention_address);
		210	}
		211	}
		212
		213	# else // _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
		214
		215	template <class _AtomicWaitable>
		216	_LIBCPP_HIDE_FROM_ABI void __atomic_notify_one(const _AtomicWaitable& __a) {
		217	static_assert(__atomic_waitable<_AtomicWaitable>);
147	std::__cxx_atomic_notify_one(__atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_contention_address(__a));	218	std::__cxx_atomic_notify_one(__atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_contention_address(__a));
148	}	219	}
149		220
150	template <class _AtomicWaitable>	221	template <class _AtomicWaitable>
151	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void __atomic_notify_all(const _AtomicWaitable& __a) {	222	_LIBCPP_HIDE_FROM_ABI void __atomic_notify_all(const _AtomicWaitable& __a) {
152	static_assert(__atomic_waitable<_AtomicWaitable>::value, "");	223	static_assert(__atomic_waitable<_AtomicWaitable>);
153	std::__cxx_atomic_notify_all(__atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_contention_address(__a));	224	std::__cxx_atomic_notify_all(__atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_contention_address(__a));
154	}	225	}
155		226
		227	# endif
		228
156	# else // _LIBCPP_HAS_THREADS	229	# else // _LIBCPP_HAS_THREADS
157		230
158	template <class _AtomicWaitable, class _Poll>	231	template <class _AtomicWaitable, class _Poll>
...	@@ -180,9 +253,8 @@ _LIBCPP_HIDE_FROM_ABI bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp c	...	@@ -180,9 +253,8 @@ _LIBCPP_HIDE_FROM_ABI bool __cxx_nonatomic_compare_equal(_Tp const& __lhs, _Tp c
180	}	253	}
181		254
182	template <class _AtomicWaitable, class _Tp>	255	template <class _AtomicWaitable, class _Tp>
183	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void	256	_LIBCPP_HIDE_FROM_ABI void __atomic_wait(_AtomicWaitable& __a, _Tp __val, memory_order __order) {
184	__atomic_wait(_AtomicWaitable& __a, _Tp __val, memory_order __order) {	257	static_assert(__atomic_waitable<_AtomicWaitable>);
185	static_assert(__atomic_waitable<_AtomicWaitable>::value, "");
186	std::__atomic_wait_unless(__a, __order, [&](_Tp const& __current) {	258	std::__atomic_wait_unless(__a, __order, [&](_Tp const& __current) {
187	return !std::__cxx_nonatomic_compare_equal(__current, __val);	259	return !std::__cxx_nonatomic_compare_equal(__current, __val);
188	});	260	});

lib/libcxx/include/__atomic/atomic_sync_timed.h created+144

...	@@ -0,0 +1,144 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___ATOMIC_ATOMIC_SYNC_TIMED_H
10	#define _LIBCPP___ATOMIC_ATOMIC_SYNC_TIMED_H
11
12	#include <__atomic/atomic_waitable_traits.h>
13	#include <__atomic/contention_t.h>
14	#include <__atomic/memory_order.h>
15	#include <__atomic/to_gcc_order.h>
16	#include <__chrono/duration.h>
17	#include <__config>
18	#include <__memory/addressof.h>
19	#include <__thread/poll_with_backoff.h>
20	#include <__thread/timed_backoff_policy.h>
21	#include <__type_traits/conjunction.h>
22	#include <__type_traits/decay.h>
23	#include <__type_traits/has_unique_object_representation.h>
24	#include <__type_traits/invoke.h>
25	#include <__type_traits/is_same.h>
26	#include <__type_traits/is_trivially_copyable.h>
27	#include <__type_traits/void_t.h>
28	#include <__utility/declval.h>
29	#include <cstdint>
30	#include <cstring>
31
32	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
33	# pragma GCC system_header
34	#endif
35
36	_LIBCPP_BEGIN_NAMESPACE_STD
37
38	#if _LIBCPP_STD_VER >= 20
39	# if _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
40
41	_LIBCPP_AVAILABILITY_NEW_SYNC
42	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __atomic_monitor_global(void const* __address) _NOEXCEPT;
43
44	// wait on the global contention state to be changed from the given value for the address
45	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_global_table_with_timeout(
46	void const* __address, __cxx_contention_t __monitor_value, uint64_t __timeout_ns) _NOEXCEPT;
47
48	// wait on the address directly with the native platform wait
49	template <std::size_t _Size>
50	_LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_EXPORTED_FROM_ABI void
51	__atomic_wait_native_with_timeout(void const* __address, void const* __old_value, uint64_t __timeout_ns) _NOEXCEPT;
52
53	template <class _AtomicWaitable, class _Poll, class _Rep, class _Period>
54	struct __atomic_wait_timed_backoff_impl {
55	const _AtomicWaitable& __a_;
56	_Poll __poll_;
57	memory_order __order_;
58	chrono::duration<_Rep, _Period> __rel_time_;
59
60	using __waitable_traits _LIBCPP_NODEBUG = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >;
61	using __value_type _LIBCPP_NODEBUG = typename __waitable_traits::__value_type;
62
63	_LIBCPP_HIDE_FROM_ABI __backoff_results operator()(chrono::nanoseconds __elapsed) const {
64	if (__elapsed > chrono::microseconds(4)) {
65	auto __contention_address = const_cast<const void*>(
66	static_cast<const volatile void*>(__waitable_traits::__atomic_contention_address(__a_)));
67
68	uint64_t __timeout_ns =
69	static_cast<uint64_t>((chrono::duration_cast<chrono::nanoseconds>(__rel_time_) - __elapsed).count());
70
71	if constexpr (__has_native_atomic_wait<__value_type>) {
72	auto __atomic_value = __waitable_traits::__atomic_load(__a_, __order_);
73	if (__poll_(__atomic_value))
74	return __backoff_results::__poll_success;
75	std::__atomic_wait_native_with_timeout<sizeof(__value_type)>(
76	__contention_address, std::addressof(__atomic_value), __timeout_ns);
77	} else {
78	__cxx_contention_t __monitor_val = std::__atomic_monitor_global(__contention_address);
79	auto __atomic_value = __waitable_traits::__atomic_load(__a_, __order_);
80	if (__poll_(__atomic_value))
81	return __backoff_results::__poll_success;
82	std::__atomic_wait_global_table_with_timeout(__contention_address, __monitor_val, __timeout_ns);
83	}
84	} else {
85	} // poll
86	return __backoff_results::__continue_poll;
87	}
88	};
89
90	// The semantics of this function are similar to `atomic`'s
91	// `.wait(T old, std::memory_order order)` with a timeout, but instead of having a hardcoded
92	// predicate (is the loaded value unequal to `old`?), the predicate function is
93	// specified as an argument. The loaded value is given as an in-out argument to
94	// the predicate. If the predicate function returns `true`,
95	// `__atomic_wait_unless_with_timeout` will return. If the predicate function returns
96	// `false`, it must set the argument to its current understanding of the atomic
97	// value. The predicate function must not return `false` spuriously.
98	template <class _AtomicWaitable, class _Poll, class _Rep, class _Period>
99	_LIBCPP_HIDE_FROM_ABI bool __atomic_wait_unless_with_timeout(
100	const _AtomicWaitable& __a,
101	memory_order __order,
102	_Poll&& __poll,
103	chrono::duration<_Rep, _Period> const& __rel_time) {
104	static_assert(__atomic_waitable<_AtomicWaitable>, "");
105	__atomic_wait_timed_backoff_impl<_AtomicWaitable, __decay_t<_Poll>, _Rep, _Period> __backoff_fn = {
106	__a, __poll, __order, __rel_time};
107	auto __poll_result = std::__libcpp_thread_poll_with_backoff(
108	/* poll */
109	[&]() {
110	auto __current_val = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_load(__a, __order);
111	return __poll(__current_val);
112	},
113	/* backoff */ __backoff_fn,
114	__rel_time);
115
116	return __poll_result == __poll_with_backoff_results::__poll_success;
117	}
118
119	# elif _LIBCPP_HAS_THREADS // _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
120
121	template <class _AtomicWaitable, class _Poll, class _Rep, class _Period>
122	_LIBCPP_HIDE_FROM_ABI bool __atomic_wait_unless_with_timeout(
123	const _AtomicWaitable& __a,
124	memory_order __order,
125	_Poll&& __poll,
126	chrono::duration<_Rep, _Period> const& __rel_time) {
127	auto __res = std::__libcpp_thread_poll_with_backoff(
128	/* poll */
129	[&]() {
130	auto __current_val = __atomic_waitable_traits<__decay_t<_AtomicWaitable> >::__atomic_load(__a, __order);
131	return __poll(__current_val);
132	},
133	/* backoff */ __libcpp_timed_backoff_policy(),
134	__rel_time);
135	return __res == __poll_with_backoff_results::__poll_success;
136	}
137
138	# endif // _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_NEW_SYNC
139
140	#endif // C++20
141
142	_LIBCPP_END_NAMESPACE_STD
143
144	#endif // _LIBCPP___ATOMIC_ATOMIC_SYNC_TIMED_H

lib/libcxx/include/__atomic/atomic_waitable_traits.h created+103

...	@@ -0,0 +1,103 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___ATOMIC_ATOMIC_WAITABLE_TRAITS_H
10	#define _LIBCPP___ATOMIC_ATOMIC_WAITABLE_TRAITS_H
11
12	#include <__atomic/contention_t.h>
13	#include <__atomic/memory_order.h>
14	#include <__config>
15	#include <__type_traits/decay.h>
16	#include <__type_traits/has_unique_object_representation.h>
17	#include <__type_traits/is_same.h>
18	#include <__type_traits/is_trivially_copyable.h>
19	#include <__type_traits/void_t.h>
20	#include <__utility/declval.h>
21	#include <cstring>
22
23	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
24	# pragma GCC system_header
25	#endif
26
27	_LIBCPP_BEGIN_NAMESPACE_STD
28
29	#if _LIBCPP_STD_VER >= 20
30
31	// The customisation points to enable the following functions:
32	// - __atomic_wait
33	// - __atomic_wait_unless
34	// - __atomic_notify_one
35	// - __atomic_notify_all
36	template <class _Tp, class = void>
37	struct __atomic_waitable_traits {
38	using __value_type _LIBCPP_NODEBUG = void;
39
40	template <class _AtomicWaitable>
41	static void __atomic_load(_AtomicWaitable&&, memory_order) = delete;
42
43	template <class _AtomicWaitable>
44	static void __atomic_contention_address(_AtomicWaitable&&) = delete;
45	};
46
47	template <class _Tp>
48	concept __atomic_waitable = requires(const _Tp __t, memory_order __order) {
49	typename __atomic_waitable_traits<__decay_t<_Tp> >::__value_type;
50	{ __atomic_waitable_traits<__decay_t<_Tp> >::__atomic_load(__t, __order) };
51	{ __atomic_waitable_traits<__decay_t<_Tp> >::__atomic_contention_address(__t) };
52	};
53
54	# ifdef __linux__
55	# define _LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_APPLY) _APPLY(4)
56	# elif defined(__APPLE__)
57	# define _LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_APPLY) \
58	_APPLY(4) \
59	_APPLY(8)
60	# elif defined(__FreeBSD__) && __SIZEOF_LONG__ == 8
61	# define _LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_APPLY) _APPLY(8)
62	# elif defined(_WIN32)
63	# define _LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_APPLY) _APPLY(8)
64	# else
65	# define _LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_APPLY) _APPLY(sizeof(__cxx_contention_t))
66	# endif // __linux__
67
68	// concepts defines the types are supported natively by the platform's wait
69
70	# if defined(_LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE)
71
72	template <class _Tp>
73	_LIBCPP_HIDE_FROM_ABI constexpr bool __has_native_atomic_wait_impl() {
74	if (alignof(_Tp) % sizeof(_Tp) != 0)
75	return false;
76	switch (sizeof(_Tp)) {
77	# define _LIBCPP_MAKE_CASE(n) \
78	case n: \
79	return true;
80	_LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_LIBCPP_MAKE_CASE)
81	default:
82	return false;
83	# undef _LIBCPP_MAKE_CASE
84	};
85	}
86
87	template <class _Tp>
88	concept __has_native_atomic_wait =
89	has_unique_object_representations_v<_Tp> && is_trivially_copyable_v<_Tp> &&
90	std::__has_native_atomic_wait_impl<_Tp>();
91
92	# else // _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
93
94	template <class _Tp>
95	concept __has_native_atomic_wait = is_same_v<_Tp, __cxx_contention_t>;
96
97	# endif // _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
98
99	#endif // C++20
100
101	_LIBCPP_END_NAMESPACE_STD
102
103	#endif // _LIBCPP___ATOMIC_ATOMIC_WAITABLE_TRAITS_H

lib/libcxx/include/__atomic/contention_t.h+27-3

...	@@ -19,11 +19,35 @@	...	@@ -19,11 +19,35 @@
19		19
20	_LIBCPP_BEGIN_NAMESPACE_STD	20	_LIBCPP_BEGIN_NAMESPACE_STD
21		21
22	#if defined(__linux__) \|\| (defined(_AIX) && !defined(__64BIT__))	22	// The original definition of `__cxx_contention_t` seemed a bit arbitrary.
		23	// When we enable the _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE ABI,
		24	// use definitions that are based on what the underlying platform supports
		25	// instead.
		26	#if defined(_LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE)
		27
		28	# ifdef __linux__
		29	using __cxx_contention_t _LIBCPP_NODEBUG = int32_t;
		30	# elif defined(__APPLE__)
		31	using __cxx_contention_t _LIBCPP_NODEBUG = int64_t;
		32	# elif defined(__FreeBSD__) && __SIZEOF_LONG__ == 8
		33	using __cxx_contention_t _LIBCPP_NODEBUG = int64_t;
		34	# elif defined(_AIX) && !defined(__64BIT__)
		35	using __cxx_contention_t _LIBCPP_NODEBUG = int32_t;
		36	# elif defined(_WIN32)
		37	using __cxx_contention_t _LIBCPP_NODEBUG = int64_t;
		38	# else
		39	using __cxx_contention_t _LIBCPP_NODEBUG = int64_t;
		40	# endif // __linux__
		41
		42	#else // _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
		43
		44	# if defined(__linux__) \|\| (defined(_AIX) && !defined(__64BIT__))
23	using __cxx_contention_t _LIBCPP_NODEBUG = int32_t;	45	using __cxx_contention_t _LIBCPP_NODEBUG = int32_t;
24	#else	46	# else
25	using __cxx_contention_t _LIBCPP_NODEBUG = int64_t;	47	using __cxx_contention_t _LIBCPP_NODEBUG = int64_t;
26	#endif // __linux__ \|\| (_AIX && !__64BIT__)	48	# endif // __linux__ \|\| (_AIX && !__64BIT__)
		49
		50	#endif // _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
27		51
28	using __cxx_atomic_contention_t _LIBCPP_NODEBUG = __cxx_atomic_impl<__cxx_contention_t>;	52	using __cxx_atomic_contention_t _LIBCPP_NODEBUG = __cxx_atomic_impl<__cxx_contention_t>;
29		53

lib/libcxx/include/__atomic/floating_point_helper.h created+55

...	@@ -0,0 +1,55 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___ATOMIC_FLOATING_POINT_HELPER_H
10	#define _LIBCPP___ATOMIC_FLOATING_POINT_HELPER_H
11
12	#include <__config>
13	#include <__type_traits/is_floating_point.h>
14	#include <__type_traits/is_same.h>
15
16	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
17	# pragma GCC system_header
18	#endif
19
20	_LIBCPP_BEGIN_NAMESPACE_STD
21
22	#if _LIBCPP_STD_VER >= 20
23
24	template <class _Tp>
25	_LIBCPP_HIDE_FROM_ABI constexpr bool __is_fp80_long_double() {
26	// Only x87-fp80 long double has 64-bit mantissa
27	return __LDBL_MANT_DIG__ == 64 && std::is_same_v<_Tp, long double>;
28	}
29
30	template <class _Tp>
31	_LIBCPP_HIDE_FROM_ABI constexpr bool __has_rmw_builtin() {
32	static_assert(std::is_floating_point_v<_Tp>);
33	# ifndef _LIBCPP_COMPILER_CLANG_BASED
34	return false;
35	# else
36	// The builtin __cxx_atomic_fetch_add errors during compilation for
37	// long double on platforms with fp80 format.
38	// For more details, see
39	// lib/Sema/SemaChecking.cpp function IsAllowedValueType
40	// LLVM Parser does not allow atomicrmw with x86_fp80 type.
41	// if (ValType->isSpecificBuiltinType(BuiltinType::LongDouble) &&
42	// &Context.getTargetInfo().getLongDoubleFormat() ==
43	// &llvm::APFloat::x87DoubleExtended())
44	// For more info
45	// https://llvm.org/PR68602
46	// https://reviews.llvm.org/D53965
47	return !std::__is_fp80_long_double<_Tp>();
48	# endif
49	}
50
51	#endif
52
53	_LIBCPP_END_NAMESPACE_STD
54
55	#endif // _LIBCPP___ATOMIC_FLOATING_POINT_HELPER_H

lib/libcxx/include/__bit/countl.h+1-2

...	@@ -24,7 +24,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -24,7 +24,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
24		24
25	template <class _Tp>	25	template <class _Tp>
26	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countl_zero(_Tp __t) _NOEXCEPT {	26	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 int __countl_zero(_Tp __t) _NOEXCEPT {
27	static_assert(__is_unsigned_integer_v<_Tp>, "__countl_zero requires an unsigned integer type");
28	return __builtin_clzg(__t, numeric_limits<_Tp>::digits);	27	return __builtin_clzg(__t, numeric_limits<_Tp>::digits);
29	}	28	}
30		29
...	@@ -37,7 +36,7 @@ template <__unsigned_integer _Tp>	...	@@ -37,7 +36,7 @@ template <__unsigned_integer _Tp>
37		36
38	template <__unsigned_integer _Tp>	37	template <__unsigned_integer _Tp>
39	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countl_one(_Tp __t) noexcept {	38	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countl_one(_Tp __t) noexcept {
40	return __t != numeric_limits<_Tp>::max() ? std::countl_zero(static_cast<_Tp>(~__t)) : numeric_limits<_Tp>::digits;	39	return std::countl_zero(static_cast<_Tp>(~__t));
41	}	40	}
42		41
43	#endif // _LIBCPP_STD_VER >= 20	42	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__bit/countr.h+1-2

...	@@ -24,7 +24,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -24,7 +24,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
24		24
25	template <class _Tp>	25	template <class _Tp>
26	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero(_Tp __t) _NOEXCEPT {	26	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __countr_zero(_Tp __t) _NOEXCEPT {
27	static_assert(__is_unsigned_integer_v<_Tp>, "__countr_zero only works with unsigned types");
28	return __builtin_ctzg(__t, numeric_limits<_Tp>::digits);	27	return __builtin_ctzg(__t, numeric_limits<_Tp>::digits);
29	}	28	}
30		29
...	@@ -37,7 +36,7 @@ template <__unsigned_integer _Tp>	...	@@ -37,7 +36,7 @@ template <__unsigned_integer _Tp>
37		36
38	template <__unsigned_integer _Tp>	37	template <__unsigned_integer _Tp>
39	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countr_one(_Tp __t) noexcept {	38	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr int countr_one(_Tp __t) noexcept {
40	return __t != numeric_limits<_Tp>::max() ? std::countr_zero(static_cast<_Tp>(~__t)) : numeric_limits<_Tp>::digits;	39	return std::countr_zero(static_cast<_Tp>(~__t));
41	}	40	}
42		41
43	#endif // _LIBCPP_STD_VER >= 20	42	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__bit/has_single_bit.h+1-1

...	@@ -25,7 +25,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -25,7 +25,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
25		25
26	template <__unsigned_integer _Tp>	26	template <__unsigned_integer _Tp>
27	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_single_bit(_Tp __t) noexcept {	27	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_single_bit(_Tp __t) noexcept {
28	return __t != 0 && (((__t & (__t - 1)) == 0));	28	return __builtin_popcountg(__t) == 1;
29	}	29	}
30		30
31	_LIBCPP_END_NAMESPACE_STD	31	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__bit/popcount.h-1

...	@@ -23,7 +23,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -23,7 +23,6 @@ _LIBCPP_BEGIN_NAMESPACE_STD
23		23
24	template <class _Tp>	24	template <class _Tp>
25	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __popcount(_Tp __t) _NOEXCEPT {	25	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int __popcount(_Tp __t) _NOEXCEPT {
26	static_assert(__is_unsigned_integer_v<_Tp>, "__popcount only works with unsigned types");
27	return __builtin_popcountg(__t);	26	return __builtin_popcountg(__t);
28	}	27	}
29		28

lib/libcxx/include/__bit/rotate.h+15-26

...	@@ -22,46 +22,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -22,46 +22,35 @@ _LIBCPP_BEGIN_NAMESPACE_STD
22	// Writing two full functions for rotl and rotr makes it easier for the compiler	22	// Writing two full functions for rotl and rotr makes it easier for the compiler
23	// to optimize the code. On x86 this function becomes the ROL instruction and	23	// to optimize the code. On x86 this function becomes the ROL instruction and
24	// the rotr function becomes the ROR instruction.	24	// the rotr function becomes the ROR instruction.
25	template <class _Tp>	25
26	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotl(_Tp __x, int __s) _NOEXCEPT {	26	#if _LIBCPP_STD_VER >= 20
27	static_assert(__is_unsigned_integer_v<_Tp>, "__rotl requires an unsigned integer type");	27
		28	template <__unsigned_integer _Tp>
		29	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, int __cnt) noexcept {
28	const int __n = numeric_limits<_Tp>::digits;	30	const int __n = numeric_limits<_Tp>::digits;
29	int __r = __s % __n;	31	int __r = __cnt % __n;
30		32
31	if (__r == 0)	33	if (__r == 0)
32	return __x;	34	return __t;
33		35
34	if (__r > 0)	36	if (__r > 0)
35	return (__x << __r) \| (__x >> (__n - __r));	37	return (__t << __r) \| (__t >> (__n - __r));
36		38
37	return (__x >> -__r) \| (__x << (__n + __r));	39	return (__t >> -__r) \| (__t << (__n + __r));
38	}	40	}
39		41
40	template <class _Tp>	42	template <__unsigned_integer _Tp>
41	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp __rotr(_Tp __x, int __s) _NOEXCEPT {	43	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, int __cnt) noexcept {
42	static_assert(__is_unsigned_integer_v<_Tp>, "__rotr requires an unsigned integer type");
43	const int __n = numeric_limits<_Tp>::digits;	44	const int __n = numeric_limits<_Tp>::digits;
44	int __r = __s % __n;	45	int __r = __cnt % __n;
45		46
46	if (__r == 0)	47	if (__r == 0)
47	return __x;	48	return __t;
48		49
49	if (__r > 0)	50	if (__r > 0)
50	return (__x >> __r) \| (__x << (__n - __r));	51	return (__t >> __r) \| (__t << (__n - __r));
51
52	return (__x << -__r) \| (__x >> (__n + __r));
53	}
54		52
55	#if _LIBCPP_STD_VER >= 20	53	return (__t << -__r) \| (__t >> (__n + __r));
56
57	template <__unsigned_integer _Tp>
58	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotl(_Tp __t, int __cnt) noexcept {
59	return std::__rotl(__t, __cnt);
60	}
61
62	template <__unsigned_integer _Tp>
63	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp rotr(_Tp __t, int __cnt) noexcept {
64	return std::__rotr(__t, __cnt);
65	}	54	}
66		55
67	#endif // _LIBCPP_STD_VER >= 20	56	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__bit_reference+207-18

...	@@ -15,8 +15,10 @@	...	@@ -15,8 +15,10 @@
15	#include <__algorithm/copy_backward.h>	15	#include <__algorithm/copy_backward.h>
16	#include <__algorithm/copy_n.h>	16	#include <__algorithm/copy_n.h>
17	#include <__algorithm/equal.h>	17	#include <__algorithm/equal.h>
		18	#include <__algorithm/fill_n.h>
18	#include <__algorithm/min.h>	19	#include <__algorithm/min.h>
19	#include <__algorithm/rotate.h>	20	#include <__algorithm/rotate.h>
		21	#include <__algorithm/specialized_algorithms.h>
20	#include <__algorithm/swap_ranges.h>	22	#include <__algorithm/swap_ranges.h>
21	#include <__assert>	23	#include <__assert>
22	#include <__bit/countr.h>	24	#include <__bit/countr.h>
...	@@ -137,7 +139,7 @@ public:	...	@@ -137,7 +139,7 @@ public:
137	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator bool() const _NOEXCEPT {	139	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator bool() const _NOEXCEPT {
138	return static_cast<bool>(*__seg_ & __mask_);	140	return static_cast<bool>(*__seg_ & __mask_);
139	}	141	}
140	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator~() const _NOEXCEPT {	142	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool operator~() const _NOEXCEPT {
141	return !static_cast<bool>(*this);	143	return !static_cast<bool>(*this);
142	}	144	}
143		145
...	@@ -307,6 +309,15 @@ public:	...	@@ -307,6 +309,15 @@ public:
307	{	309	{
308	}	310	}
309		311
		312	#ifdef _LIBCPP_ABI_TRIVIALLY_COPYABLE_BIT_ITERATOR
		313	template <bool _IsConstDep = _IsConst, __enable_if_t<_IsConstDep, int> = 0>
		314	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bit_iterator(const __bit_iterator<_Cp, false>& __it) _NOEXCEPT
		315	: __seg_(__it.__seg_),
		316	__ctz_(__it.__ctz_) {}
		317
		318	_LIBCPP_HIDE_FROM_ABI __bit_iterator(const __bit_iterator&) = default;
		319	_LIBCPP_HIDE_FROM_ABI __bit_iterator& operator=(const __bit_iterator&) = default;
		320	#else
310	// When _IsConst=false, this is the copy constructor.	321	// When _IsConst=false, this is the copy constructor.
311	// It is non-trivial. Making it trivial would break ABI.	322	// It is non-trivial. Making it trivial would break ABI.
312	// When _IsConst=true, this is a converting constructor;	323	// When _IsConst=true, this is a converting constructor;
...	@@ -327,6 +338,7 @@ public:	...	@@ -327,6 +338,7 @@ public:
327	__ctz_ = __it.__ctz_;	338	__ctz_ = __it.__ctz_;
328	return *this;	339	return *this;
329	}	340	}
		341	#endif
330		342
331	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator*() const _NOEXCEPT {	343	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator*() const _NOEXCEPT {
332	_LIBCPP_ASSERT_INTERNAL(__ctz_ < __bits_per_word, "Dereferencing an invalid __bit_iterator.");	344	_LIBCPP_ASSERT_INTERNAL(__ctz_ < __bits_per_word, "Dereferencing an invalid __bit_iterator.");
...	@@ -467,20 +479,6 @@ private:	...	@@ -467,20 +479,6 @@ private:
467	template <class _Dp>	479	template <class _Dp>
468	friend struct __bit_array;	480	friend struct __bit_array;
469		481
470	template <bool _FillVal, class _Dp>
471	_LIBCPP_CONSTEXPR_SINCE_CXX20 friend void
472	__fill_n_bool(__bit_iterator<_Dp, false> __first, typename __size_difference_type_traits<_Dp>::size_type __n);
473
474	template <class _Dp, bool _IC>
475	_LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_aligned(
476	__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
477	template <class _Dp, bool _IC>
478	_LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_unaligned(
479	__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
480	template <class _Dp, bool _IC>
481	_LIBCPP_CONSTEXPR_SINCE_CXX20 friend pair<__bit_iterator<_Dp, _IC>, __bit_iterator<_Dp, false> >
482	__copy_impl::operator()(
483	__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result) const;
484	template <class _Dp, bool _IC>	482	template <class _Dp, bool _IC>
485	_LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_aligned(	483	_LIBCPP_CONSTEXPR_SINCE_CXX20 friend __bit_iterator<_Dp, false> __copy_backward_aligned(
486	__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);	484	__bit_iterator<_Dp, _IC> __first, __bit_iterator<_Dp, _IC> __last, __bit_iterator<_Dp, false> __result);
...	@@ -511,10 +509,20 @@ private:	...	@@ -511,10 +509,20 @@ private:
511	bool _IsConst1,	509	bool _IsConst1,
512	bool _IsConst2,	510	bool _IsConst2,
513	class _BinaryPredicate,	511	class _BinaryPredicate,
514	__enable_if_t<__desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>, int> >	512	class _Proj1,
		513	class _Proj2,
		514	__enable_if_t<__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
		515	__desugars_to_v<__equal_tag, _BinaryPredicate, bool, bool>,
		516	int> >
515	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool __equal_iter_impl(	517	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 friend bool __equal_iter_impl(
516	__bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst1>, __bit_iterator<_Dp, _IsConst2>, _BinaryPredicate);	518	__bit_iterator<_Dp, _IsConst1>,
517	template <class _Dp,	519	__bit_iterator<_Dp, _IsConst1>,
		520	__bit_iterator<_Dp, _IsConst2>,
		521	_BinaryPredicate,
		522	_Proj1&,
		523	_Proj2&);
		524	template <bool,
		525	class _Dp,
518	bool _IsConst1,	526	bool _IsConst1,
519	bool _IsConst2,	527	bool _IsConst2,
520	class _Pred,	528	class _Pred,
...	@@ -537,6 +545,187 @@ private:	...	@@ -537,6 +545,187 @@ private:
537	template <bool _ToCount, class _Dp, bool _IC>	545	template <bool _ToCount, class _Dp, bool _IC>
538	friend typename __bit_iterator<_Dp, _IC>::difference_type _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20	546	friend typename __bit_iterator<_Dp, _IC>::difference_type _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
539	__count_bool(__bit_iterator<_Dp, _IC>, typename __size_difference_type_traits<_Dp>::size_type);	547	__count_bool(__bit_iterator<_Dp, _IC>, typename __size_difference_type_traits<_Dp>::size_type);
		548
		549	template <class, class...>
		550	friend struct __specialized_algorithm;
		551	};
		552
		553	template <class _Cp>
		554	struct __specialized_algorithm<_Algorithm::__fill_n, __single_iterator<__bit_iterator<_Cp, false> > > {
		555	static const bool __has_algorithm = true;
		556
		557	template <bool _FillVal>
		558	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static void
		559	__impl(__bit_iterator<_Cp, false> __first, typename __size_difference_type_traits<_Cp>::size_type __n) {
		560	using _It = __bit_iterator<_Cp, false>;
		561	using __storage_type = typename _It::__storage_type;
		562
		563	const int __bits_per_word = _It::__bits_per_word;
		564	// do first partial word
		565	if (__first.__ctz_ != 0) {
		566	__storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
		567	__storage_type __dn = std::min(__clz_f, __n);
		568	std::__fill_masked_range(std::__to_address(__first.__seg_), __clz_f - __dn, __first.__ctz_, _FillVal);
		569	__n -= __dn;
		570	++__first.__seg_;
		571	}
		572	// do middle whole words
		573	__storage_type __nw = __n / __bits_per_word;
		574	std::__fill_n(std::__to_address(__first.__seg_), __nw, _FillVal ? static_cast<__storage_type>(-1) : 0);
		575	__n -= __nw * __bits_per_word;
		576	// do last partial word
		577	if (__n > 0) {
		578	__first.__seg_ += __nw;
		579	std::__fill_masked_range(std::__to_address(__first.__seg_), __bits_per_word - __n, 0u, _FillVal);
		580	}
		581	}
		582
		583	template <class _Size, class _Tp>
		584	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
		585	operator()(__bit_iterator<_Cp, false> __first, _Size __n, const _Tp& __value) {
		586	if (__n > 0) {
		587	if (__value)
		588	__impl<true>(__first, __n);
		589	else
		590	__impl<false>(__first, __n);
		591	}
		592	return __first + __n;
		593	}
		594	};
		595
		596	template <class _Cp, bool _IsConst>
		597	struct __specialized_algorithm<_Algorithm::__copy,
		598	__iterator_pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, _IsConst> >,
		599	__single_iterator<__bit_iterator<_Cp, false> > > {
		600	static const bool __has_algorithm = true;
		601
		602	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
		603	__aligned_impl(__bit_iterator<_Cp, _IsConst> __first,
		604	__bit_iterator<_Cp, _IsConst> __last,
		605	__bit_iterator<_Cp, false> __result) {
		606	using _In = __bit_iterator<_Cp, _IsConst>;
		607	using difference_type = typename _In::difference_type;
		608	using __storage_type = typename _In::__storage_type;
		609
		610	const int __bits_per_word = _In::__bits_per_word;
		611	difference_type __n = __last - __first;
		612	if (__n > 0) {
		613	// do first word
		614	if (__first.__ctz_ != 0) {
		615	unsigned __clz = __bits_per_word - __first.__ctz_;
		616	difference_type __dn = std::min(static_cast<difference_type>(__clz), __n);
		617	__n -= __dn;
		618	__storage_type __m = std::__middle_mask<__storage_type>(__clz - __dn, __first.__ctz_);
		619	__storage_type __b = *__first.__seg_ & __m;
		620	*__result.__seg_ &= ~__m;
		621	*__result.__seg_ \|= __b;
		622	__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
		623	__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
		624	++__first.__seg_;
		625	// __first.__ctz_ = 0;
		626	}
		627	// __first.__ctz_ == 0;
		628	// do middle words
		629	__storage_type __nw = __n / __bits_per_word;
		630	std::copy(std::__to_address(__first.__seg_),
		631	std::__to_address(__first.__seg_ + __nw),
		632	std::__to_address(__result.__seg_));
		633	__n -= __nw * __bits_per_word;
		634	__result.__seg_ += __nw;
		635	// do last word
		636	if (__n > 0) {
		637	__first.__seg_ += __nw;
		638	__storage_type __m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
		639	__storage_type __b = *__first.__seg_ & __m;
		640	*__result.__seg_ &= ~__m;
		641	*__result.__seg_ \|= __b;
		642	__result.__ctz_ = static_cast<unsigned>(__n);
		643	}
		644	}
		645	return __result;
		646	}
		647
		648	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static __bit_iterator<_Cp, false>
		649	__unaligned_impl(__bit_iterator<_Cp, _IsConst> __first,
		650	__bit_iterator<_Cp, _IsConst> __last,
		651	__bit_iterator<_Cp, false> __result) {
		652	using _In = __bit_iterator<_Cp, _IsConst>;
		653	using difference_type = typename _In::difference_type;
		654	using __storage_type = typename _In::__storage_type;
		655
		656	const int __bits_per_word = _In::__bits_per_word;
		657	difference_type __n = __last - __first;
		658	if (__n > 0) {
		659	// do first word
		660	if (__first.__ctz_ != 0) {
		661	unsigned __clz_f = __bits_per_word - __first.__ctz_;
		662	difference_type __dn = std::min(static_cast<difference_type>(__clz_f), __n);
		663	__n -= __dn;
		664	__storage_type __m = std::__middle_mask<__storage_type>(__clz_f - __dn, __first.__ctz_);
		665	__storage_type __b = *__first.__seg_ & __m;
		666	unsigned __clz_r = __bits_per_word - __result.__ctz_;
		667	__storage_type __ddn = std::min<__storage_type>(__dn, __clz_r);
		668	__m = std::__middle_mask<__storage_type>(__clz_r - __ddn, __result.__ctz_);
		669	*__result.__seg_ &= ~__m;
		670	if (__result.__ctz_ > __first.__ctz_)
		671	*__result.__seg_ \|= __b << (__result.__ctz_ - __first.__ctz_);
		672	else
		673	*__result.__seg_ \|= __b >> (__first.__ctz_ - __result.__ctz_);
		674	__result.__seg_ += (__ddn + __result.__ctz_) / __bits_per_word;
		675	__result.__ctz_ = static_cast<unsigned>((__ddn + __result.__ctz_) % __bits_per_word);
		676	__dn -= __ddn;
		677	if (__dn > 0) {
		678	__m = std::__trailing_mask<__storage_type>(__bits_per_word - __dn);
		679	*__result.__seg_ &= ~__m;
		680	*__result.__seg_ \|= __b >> (__first.__ctz_ + __ddn);
		681	__result.__ctz_ = static_cast<unsigned>(__dn);
		682	}
		683	++__first.__seg_;
		684	// __first.__ctz_ = 0;
		685	}
		686	// __first.__ctz_ == 0;
		687	// do middle words
		688	unsigned __clz_r = __bits_per_word - __result.__ctz_;
		689	__storage_type __m = std::__leading_mask<__storage_type>(__result.__ctz_);
		690	for (; __n >= __bits_per_word; __n -= __bits_per_word, ++__first.__seg_) {
		691	__storage_type __b = *__first.__seg_;
		692	*__result.__seg_ &= ~__m;
		693	*__result.__seg_ \|= __b << __result.__ctz_;
		694	++__result.__seg_;
		695	*__result.__seg_ &= __m;
		696	*__result.__seg_ \|= __b >> __clz_r;
		697	}
		698	// do last word
		699	if (__n > 0) {
		700	__m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
		701	__storage_type __b = *__first.__seg_ & __m;
		702	__storage_type __dn = std::min(__n, static_cast<difference_type>(__clz_r));
		703	__m = std::__middle_mask<__storage_type>(__clz_r - __dn, __result.__ctz_);
		704	*__result.__seg_ &= ~__m;
		705	*__result.__seg_ \|= __b << __result.__ctz_;
		706	__result.__seg_ += (__dn + __result.__ctz_) / __bits_per_word;
		707	__result.__ctz_ = static_cast<unsigned>((__dn + __result.__ctz_) % __bits_per_word);
		708	__n -= __dn;
		709	if (__n > 0) {
		710	__m = std::__trailing_mask<__storage_type>(__bits_per_word - __n);
		711	*__result.__seg_ &= ~__m;
		712	*__result.__seg_ \|= __b >> __dn;
		713	__result.__ctz_ = static_cast<unsigned>(__n);
		714	}
		715	}
		716	}
		717	return __result;
		718	}
		719
		720	_LIBCPP_HIDE_FROM_ABI
		721	_LIBCPP_CONSTEXPR_SINCE_CXX20 static pair<__bit_iterator<_Cp, _IsConst>, __bit_iterator<_Cp, false> >
		722	operator()(__bit_iterator<_Cp, _IsConst> __first,
		723	__bit_iterator<_Cp, _IsConst> __last,
		724	__bit_iterator<_Cp, false> __result) {
		725	if (__first.__ctz_ == __result.__ctz_)
		726	return std::make_pair(__last, __aligned_impl(__first, __last, __result));
		727	return std::make_pair(__last, __unaligned_impl(__first, __last, __result));
		728	}
540	};	729	};
541		730
542	_LIBCPP_END_NAMESPACE_STD	731	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__charconv/from_chars_integral.h+1-1

 @@ -18,8 +18,8 @@
 #include <__memory/addressof.h>
 #include <__system_error/errc.h>
 #include <__type_traits/enable_if.h>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/is_integral.h>
+#include <__type_traits/is_signed.h>
 #include <__type_traits/is_unsigned.h>
 #include <__type_traits/make_unsigned.h>
 #include <limits>

lib/libcxx/include/__charconv/from_chars_result.h+1-1

...	@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
21		21
22	#if _LIBCPP_STD_VER >= 17	22	#if _LIBCPP_STD_VER >= 17
23		23
24	struct _LIBCPP_EXPORTED_FROM_ABI from_chars_result {	24	struct from_chars_result {
25	const char* ptr;	25	const char* ptr;
26	errc ec;	26	errc ec;
27	# if _LIBCPP_STD_VER >= 20	27	# if _LIBCPP_STD_VER >= 20

lib/libcxx/include/__charconv/to_chars_integral.h+1

...	@@ -24,6 +24,7 @@	...	@@ -24,6 +24,7 @@
24	#include <__type_traits/integral_constant.h>	24	#include <__type_traits/integral_constant.h>
25	#include <__type_traits/is_integral.h>	25	#include <__type_traits/is_integral.h>
26	#include <__type_traits/is_same.h>	26	#include <__type_traits/is_same.h>
		27	#include <__type_traits/is_signed.h>
27	#include <__type_traits/make_32_64_or_128_bit.h>	28	#include <__type_traits/make_32_64_or_128_bit.h>
28	#include <__type_traits/make_unsigned.h>	29	#include <__type_traits/make_unsigned.h>
29	#include <__utility/unreachable.h>	30	#include <__utility/unreachable.h>

lib/libcxx/include/__charconv/to_chars_result.h+1-1

...	@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -21,7 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
21		21
22	#if _LIBCPP_STD_VER >= 17	22	#if _LIBCPP_STD_VER >= 17
23		23
24	struct _LIBCPP_EXPORTED_FROM_ABI to_chars_result {	24	struct to_chars_result {
25	char* ptr;	25	char* ptr;
26	errc ec;	26	errc ec;
27	# if _LIBCPP_STD_VER >= 20	27	# if _LIBCPP_STD_VER >= 20

lib/libcxx/include/__charconv/traits.h+3-24

...	@@ -113,31 +113,10 @@ struct _LIBCPP_HIDDEN __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(__u	...	@@ -113,31 +113,10 @@ struct _LIBCPP_HIDDEN __traits_base<_Tp, __enable_if_t<sizeof(_Tp) == sizeof(__u
113	};	113	};
114	# endif	114	# endif
115		115
116	template <typename _Tp>
117	inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
118	__mul_overflowed(unsigned char __a, _Tp __b, unsigned char& __r) {
119	auto __c = __a * __b;
120	__r = __c;
121	return __c > numeric_limits<unsigned char>::max();
122	}
123
124	template <typename _Tp>
125	inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool
126	__mul_overflowed(unsigned short __a, _Tp __b, unsigned short& __r) {
127	auto __c = __a * __b;
128	__r = __c;
129	return __c > numeric_limits<unsigned short>::max();
130	}
131
132	template <typename _Tp>
133	inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool __mul_overflowed(_Tp __a, _Tp __b, _Tp& __r) {
134	static_assert(is_unsigned<_Tp>::value, "");
135	return __builtin_mul_overflow(__a, __b, std::addressof(__r));
136	}
137
138	template <typename _Tp, typename _Up>	116	template <typename _Tp, typename _Up>
139	inline _LIBCPP_HIDE_FROM_ABI bool _LIBCPP_CONSTEXPR_SINCE_CXX23 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r) {	117	_LIBCPP_HIDE_FROM_ABI bool _LIBCPP_CONSTEXPR_SINCE_CXX23 __mul_overflowed(_Tp __a, _Up __b, _Tp& __r) {
140	return __itoa::__mul_overflowed(__a, static_cast<_Tp>(__b), __r);	118	static_assert(is_unsigned<_Tp>::value);
		119	return __builtin_mul_overflow(__a, static_cast<_Tp>(__b), std::addressof(__r));
141	}	120	}
142		121
143	template <typename _Tp>	122	template <typename _Tp>

lib/libcxx/include/__chrono/day.h+11

...	@@ -13,6 +13,8 @@	...	@@ -13,6 +13,8 @@
13	#include <__chrono/duration.h>	13	#include <__chrono/duration.h>
14	#include <__compare/ordering.h>	14	#include <__compare/ordering.h>
15	#include <__config>	15	#include <__config>
		16	#include <__cstddef/size_t.h>
		17	#include <__functional/hash.h>
16		18
17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
18	# pragma GCC system_header	20	# pragma GCC system_header
...	@@ -92,6 +94,15 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr day& day::operator-=(const days& __dd) no	...	@@ -92,6 +94,15 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr day& day::operator-=(const days& __dd) no
92		94
93	} // namespace chrono	95	} // namespace chrono
94		96
		97	# if _LIBCPP_STD_VER >= 26
		98
		99	template <>
		100	struct hash<chrono::day> {
		101	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::day& __d) noexcept { return static_cast<unsigned>(__d); }
		102	};
		103
		104	# endif // _LIBCPP_STD_VER >= 26
		105
95	_LIBCPP_END_NAMESPACE_STD	106	_LIBCPP_END_NAMESPACE_STD
96		107
97	#endif // _LIBCPP_STD_VER >= 20	108	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/duration.h+58-33

 @@ -13,6 +13,8 @@
 #include <__compare/ordering.h>
 #include <__compare/three_way_comparable.h>
 #include <__config>
+#include <__cstddef/size_t.h>
+#include <__functional/hash.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_convertible.h>
 @@ -102,7 +104,8 @@ struct __duration_cast<_FromDuration, _ToDuration, _Period, false, false> {
 };
 template <class _ToDuration, class _Rep, class _Period, __enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration duration_cast(const duration<_Rep, _Period>& __fd) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration
+duration_cast(const duration<_Rep, _Period>& __fd) {
   return __duration_cast<duration<_Rep, _Period>, _ToDuration>()(__fd);
 }
 @@ -117,14 +120,18 @@ inline constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>:
 template <class _Rep>
 struct duration_values {
 public:
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT { return _Rep(0); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep zero() _NOEXCEPT { return _Rep(0); }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT { return numeric_limits<_Rep>::max(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep max() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT { return numeric_limits<_Rep>::lowest(); }
+    return numeric_limits<_Rep>::max();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR _Rep min() _NOEXCEPT {
+    return numeric_limits<_Rep>::lowest();
+  }
 };
 #if _LIBCPP_STD_VER >= 17
 template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration floor(const duration<_Rep, _Period>& __d) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration floor(const duration<_Rep, _Period>& __d) {
   _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
   if (__t > __d)
     __t = __t - _ToDuration{1};
 @@ -132,7 +139,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration floor(const duration<
 }
 template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration ceil(const duration<_Rep, _Period>& __d) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration ceil(const duration<_Rep, _Period>& __d) {
   _ToDuration __t = chrono::duration_cast<_ToDuration>(__d);
   if (__t < __d)
     __t = __t + _ToDuration{1};
 @@ -140,7 +147,7 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration ceil(const duration<_
 }
 template <class _ToDuration, class _Rep, class _Period, enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration round(const duration<_Rep, _Period>& __d) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _ToDuration round(const duration<_Rep, _Period>& __d) {
   _ToDuration __lower = chrono::floor<_ToDuration>(__d);
   _ToDuration __upper = __lower + _ToDuration{1};
   auto __lower_diff   = __d - __lower;
 @@ -220,14 +227,14 @@ public:
   // observer
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR rep count() const { return __rep_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR rep count() const { return __rep_; }
   // arithmetic
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<duration>::type operator+() const {
     return typename common_type<duration>::type(*this);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<duration>::type operator-() const {
     return typename common_type<duration>::type(-__rep_);
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 duration& operator++() {
 @@ -269,13 +276,13 @@ public:
   // special values
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration zero() _NOEXCEPT {
     return duration(duration_values<rep>::zero());
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration min() _NOEXCEPT {
     return duration(duration_values<rep>::min());
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR duration max() _NOEXCEPT {
     return duration(duration_values<rep>::max());
   }
 };
 @@ -389,7 +396,7 @@ operator<=>(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Perio
 // Duration +
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
   typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 @@ -399,7 +406,7 @@ operator+(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2
 // Duration -
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 operator-(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
   typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Cd;
 @@ -412,7 +419,8 @@ template <class _Rep1,
           class _Period,
           class _Rep2,
           __enable_if_t<is_convertible<const _Rep2&, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator*(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
   typedef typename common_type<_Rep1, _Rep2>::type _Cr;
   typedef duration<_Cr, _Period> _Cd;
 @@ -423,7 +431,8 @@ template <class _Rep1,
           class _Period,
           class _Rep2,
           __enable_if_t<is_convertible<const _Rep1&, typename common_type<_Rep1, _Rep2>::type>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator*(const _Rep1& __s, const duration<_Rep2, _Period>& __d) {
   return __d * __s;
 }
 @@ -436,7 +445,8 @@ template <class _Rep1,
           __enable_if_t<!__is_duration_v<_Rep2> &&
                             is_convertible<const _Rep2&, typename common_type<_Rep1, _Rep2>::type>::value,
                         int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
   typedef typename common_type<_Rep1, _Rep2>::type _Cr;
   typedef duration<_Cr, _Period> _Cd;
 @@ -444,7 +454,7 @@ operator/(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
 }
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<_Rep1, _Rep2>::type
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR typename common_type<_Rep1, _Rep2>::type
 operator/(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
   typedef typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type _Ct;
   return _Ct(__lhs).count() / _Ct(__rhs).count();
 @@ -458,7 +468,8 @@ template <class _Rep1,
           __enable_if_t<!__is_duration_v<_Rep2> &&
                             is_convertible<const _Rep2&, typename common_type<_Rep1, _Rep2>::type>::value,
                         int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR duration<typename common_type<_Rep1, _Rep2>::type, _Period>
 operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
   typedef typename common_type<_Rep1, _Rep2>::type _Cr;
   typedef duration<_Cr, _Period> _Cd;
 @@ -466,7 +477,7 @@ operator%(const duration<_Rep1, _Period>& __d, const _Rep2& __s) {
 }
 template <class _Rep1, class _Period1, class _Rep2, class _Period2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
 typename common_type<duration<_Rep1, _Period1>, duration<_Rep2, _Period2> >::type
 operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
   typedef typename common_type<_Rep1, _Rep2>::type _Cr;
 @@ -481,51 +492,53 @@ operator%(const duration<_Rep1, _Period1>& __lhs, const duration<_Rep2, _Period2
 inline namespace literals {
 inline namespace chrono_literals {
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::hours operator""h(unsigned long long __h) {
   return chrono::hours(static_cast<chrono::hours::rep>(__h));
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<3600, 1>> operator""h(long double __h) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<3600, 1>>
+operator""h(long double __h) {
   return chrono::duration<long double, ratio<3600, 1>>(__h);
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes operator""min(unsigned long long __m) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::minutes operator""min(unsigned long long __m) {
   return chrono::minutes(static_cast<chrono::minutes::rep>(__m));
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<60, 1>> operator""min(long double __m) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, ratio<60, 1>>
+operator""min(long double __m) {
   return chrono::duration<long double, ratio<60, 1>>(__m);
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds operator""s(unsigned long long __s) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::seconds operator""s(unsigned long long __s) {
   return chrono::seconds(static_cast<chrono::seconds::rep>(__s));
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double> operator""s(long double __s) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double> operator""s(long double __s) {
   return chrono::duration<long double>(__s);
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::milliseconds operator""ms(unsigned long long __ms) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::milliseconds operator""ms(unsigned long long __ms) {
   return chrono::milliseconds(static_cast<chrono::milliseconds::rep>(__ms));
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, milli> operator""ms(long double __ms) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, milli> operator""ms(long double __ms) {
   return chrono::duration<long double, milli>(__ms);
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::microseconds operator""us(unsigned long long __us) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::microseconds operator""us(unsigned long long __us) {
   return chrono::microseconds(static_cast<chrono::microseconds::rep>(__us));
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, micro> operator""us(long double __us) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, micro> operator""us(long double __us) {
   return chrono::duration<long double, micro>(__us);
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::nanoseconds operator""ns(unsigned long long __ns) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::nanoseconds operator""ns(unsigned long long __ns) {
   return chrono::nanoseconds(static_cast<chrono::nanoseconds::rep>(__ns));
 }
-_LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, nano> operator""ns(long double __ns) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr chrono::duration<long double, nano> operator""ns(long double __ns) {
   return chrono::duration<long double, nano>(__ns);
 }
 @@ -538,6 +551,18 @@ using namespace literals::chrono_literals;
 #endif // _LIBCPP_STD_VER >= 14
+#if _LIBCPP_STD_VER >= 26
+template <class _Rep, class _Period>
+  requires __has_enabled_hash<_Rep>::value
+struct hash<chrono::duration<_Rep, _Period>> {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::duration<_Rep, _Period>& __d) {
+    return hash<_Rep>{}(__d.count());
+  }
+};
+#endif // _LIBCPP_STD_VER >= 26
 _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_POP_MACROS

lib/libcxx/include/__chrono/file_clock.h+4-2

 @@ -60,16 +60,18 @@ struct _FilesystemClock {
   _LIBCPP_EXPORTED_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_EXPORTED_FROM_ABI static time_point now() noexcept;
+  [[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI static time_point now() noexcept;
 #  if _LIBCPP_STD_VER >= 20
   template <class _Duration>
+  [[nodiscard]]
   _LIBCPP_HIDE_FROM_ABI static chrono::sys_time<_Duration> to_sys(const chrono::file_time<_Duration>& __t) {
     return chrono::sys_time<_Duration>(__t.time_since_epoch());
   }
   template <class _Duration>
-  _LIBCPP_HIDE_FROM_ABI static chrono::file_time<_Duration> from_sys(const chrono::sys_time<_Duration>& __t) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static chrono::file_time<_Duration>
+  from_sys(const chrono::sys_time<_Duration>& __t) {
     return chrono::file_time<_Duration>(__t.time_since_epoch());
   }
 #  endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/is_clock.h created+72

...	@@ -0,0 +1,72 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___CHRONO_IS_CLOCK_H
11	#define _LIBCPP___CHRONO_IS_CLOCK_H
12
13	#include <__config>
14
15	#include <__chrono/duration.h>
16	#include <__chrono/time_point.h>
17	#include <__concepts/same_as.h>
18	#include <__type_traits/integral_constant.h>
19	#include <__type_traits/is_arithmetic.h>
20	#include <__type_traits/is_class.h>
21	#include <__type_traits/is_union.h>
22	#include <ratio>
23
24	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
25	# pragma GCC system_header
26	#endif
27
28	#if _LIBCPP_STD_VER >= 20
29
30	_LIBCPP_BEGIN_NAMESPACE_STD
31
32	namespace chrono {
33
34	// Helper to check that _Tp::time_point has the form time_point<_, typename _Tp::duration>.
35	template <class _TimePoint, class _ClockType>
36	inline constexpr bool __is_valid_clock_time_point_v = false;
37
38	template <class _TimePointClock, class _ClockType>
39	inline constexpr bool
40	__is_valid_clock_time_point_v<time_point<_TimePointClock, typename _ClockType::duration>, _ClockType> = true;
41
42	// Check if a clock satisfies the Cpp17Clock requirements as defined in [time.clock.req]
43	template <class _Tp>
44	_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_clock_v = requires {
45	typename _Tp::rep;
46	requires is_arithmetic_v<typename _Tp::rep> \|\| is_class_v<typename _Tp::rep> \|\| is_union_v<typename _Tp::rep>;
47
48	typename _Tp::period;
49	requires __is_ratio_v<typename _Tp::period>;
50
51	typename _Tp::duration;
52	requires same_as<typename _Tp::duration, duration<typename _Tp::rep, typename _Tp::period>>;
53
54	typename _Tp::time_point;
55	requires __is_valid_clock_time_point_v<typename _Tp::time_point, _Tp>;
56
57	_Tp::is_steady;
58	requires same_as<decltype((_Tp::is_steady)), const bool&>;
59
60	_Tp::now();
61	requires same_as<decltype(_Tp::now()), typename _Tp::time_point>;
62	};
63
64	template <class _Tp>
65	struct _LIBCPP_NO_SPECIALIZATIONS is_clock : bool_constant<is_clock_v<_Tp>> {};
66
67	} // namespace chrono
68
69	_LIBCPP_END_NAMESPACE_STD
70
71	#endif // _LIBCPP_STD_VER
72	#endif // _LIBCPP___CHRONO_IS_CLOCK_H

lib/libcxx/include/__chrono/leap_second.h+13

...	@@ -22,6 +22,8 @@	...	@@ -22,6 +22,8 @@
22	# include <__compare/ordering.h>	22	# include <__compare/ordering.h>
23	# include <__compare/three_way_comparable.h>	23	# include <__compare/three_way_comparable.h>
24	# include <__config>	24	# include <__config>
		25	# include <__cstddef/size_t.h>
		26	# include <__functional/hash.h>
25	# include <__utility/private_constructor_tag.h>	27	# include <__utility/private_constructor_tag.h>
26		28
27	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	29	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -122,6 +124,17 @@ private:	...	@@ -122,6 +124,17 @@ private:
122		124
123	} // namespace chrono	125	} // namespace chrono
124		126
		127	# if _LIBCPP_STD_VER >= 26
		128
		129	template <>
		130	struct hash<chrono::leap_second> {
		131	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::leap_second& __lp) noexcept {
		132	return std::__hash_combine(hash<chrono::sys_seconds>{}(__lp.date()), hash<chrono::seconds>{}(__lp.value()));
		133	}
		134	};
		135
		136	# endif // _LIBCPP_STD_VER >= 26
		137
125	# endif // _LIBCPP_STD_VER >= 20	138	# endif // _LIBCPP_STD_VER >= 20
126		139
127	_LIBCPP_END_NAMESPACE_STD	140	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__chrono/month.h+13

...	@@ -13,6 +13,8 @@	...	@@ -13,6 +13,8 @@
13	#include <__chrono/duration.h>	13	#include <__chrono/duration.h>
14	#include <__compare/ordering.h>	14	#include <__compare/ordering.h>
15	#include <__config>	15	#include <__config>
		16	#include <__cstddef/size_t.h>
		17	#include <__functional/hash.h>
16		18
17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
18	# pragma GCC system_header	20	# pragma GCC system_header
...	@@ -108,6 +110,17 @@ inline constexpr month December{12};	...	@@ -108,6 +110,17 @@ inline constexpr month December{12};
108		110
109	} // namespace chrono	111	} // namespace chrono
110		112
		113	# if _LIBCPP_STD_VER >= 26
		114
		115	template <>
		116	struct hash<chrono::month> {
		117	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::month& __m) noexcept {
		118	return static_cast<unsigned>(__m);
		119	}
		120	};
		121
		122	# endif // _LIBCPP_STD_VER >= 26
		123
111	_LIBCPP_END_NAMESPACE_STD	124	_LIBCPP_END_NAMESPACE_STD
112		125
113	#endif // _LIBCPP_STD_VER >= 20	126	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/month_weekday.h+22

...	@@ -13,6 +13,8 @@	...	@@ -13,6 +13,8 @@
13	#include <__chrono/month.h>	13	#include <__chrono/month.h>
14	#include <__chrono/weekday.h>	14	#include <__chrono/weekday.h>
15	#include <__config>	15	#include <__config>
		16	#include <__cstddef/size_t.h>
		17	#include <__functional/hash.h>
16		18
17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
18	# pragma GCC system_header	20	# pragma GCC system_header
...	@@ -98,6 +100,26 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday_last operator/(const weekda	...	@@ -98,6 +100,26 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr month_weekday_last operator/(const weekda
98	}	100	}
99	} // namespace chrono	101	} // namespace chrono
100		102
		103	# if _LIBCPP_STD_VER >= 26
		104
		105	template <>
		106	struct hash<chrono::month_weekday> {
		107	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::month_weekday& __mw) noexcept {
		108	return std::__hash_combine(
		109	hash<chrono::month>{}(__mw.month()), hash<chrono::weekday_indexed>{}(__mw.weekday_indexed()));
		110	}
		111	};
		112
		113	template <>
		114	struct hash<chrono::month_weekday_last> {
		115	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::month_weekday_last& __mwl) noexcept {
		116	return std::__hash_combine(
		117	hash<chrono::month>{}(__mwl.month()), hash<chrono::weekday_last>{}(__mwl.weekday_last()));
		118	}
		119	};
		120
		121	# endif // _LIBCPP_STD_VER >= 26
		122
101	_LIBCPP_END_NAMESPACE_STD	123	_LIBCPP_END_NAMESPACE_STD
102		124
103	#endif // _LIBCPP_STD_VER >= 20	125	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/monthday.h+20

...	@@ -15,6 +15,8 @@	...	@@ -15,6 +15,8 @@
15	#include <__chrono/month.h>	15	#include <__chrono/month.h>
16	#include <__compare/ordering.h>	16	#include <__compare/ordering.h>
17	#include <__config>	17	#include <__config>
		18	#include <__cstddef/size_t.h>
		19	#include <__functional/hash.h>
18		20
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header	22	# pragma GCC system_header
...	@@ -126,6 +128,24 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr month_day_last operator/(last_spec, int _	...	@@ -126,6 +128,24 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr month_day_last operator/(last_spec, int _
126		128
127	} // namespace chrono	129	} // namespace chrono
128		130
		131	# if _LIBCPP_STD_VER >= 26
		132
		133	template <>
		134	struct hash<chrono::month_day> {
		135	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::month_day& __md) noexcept {
		136	return std::__hash_combine(hash<chrono::month>{}(__md.month()), hash<chrono::day>{}(__md.day()));
		137	}
		138	};
		139
		140	template <>
		141	struct hash<chrono::month_day_last> {
		142	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::month_day_last& __mdl) noexcept {
		143	return hash<chrono::month>{}(__mdl.month());
		144	}
		145	};
		146
		147	# endif // _LIBCPP_STD_VER >= 26
		148
129	_LIBCPP_END_NAMESPACE_STD	149	_LIBCPP_END_NAMESPACE_STD
130		150
131	#endif // _LIBCPP_STD_VER >= 20	151	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/steady_clock.h+1-1

...	@@ -31,7 +31,7 @@ public:	...	@@ -31,7 +31,7 @@ public:
31	typedef chrono::time_point<steady_clock, duration> time_point;	31	typedef chrono::time_point<steady_clock, duration> time_point;
32	static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = true;	32	static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = true;
33		33
34	static time_point now() _NOEXCEPT;	34	[[__nodiscard__]] static time_point now() _NOEXCEPT;
35	};	35	};
36	#endif	36	#endif
37		37

lib/libcxx/include/__chrono/system_clock.h+3-3

...	@@ -31,9 +31,9 @@ public:	...	@@ -31,9 +31,9 @@ public:
31	typedef chrono::time_point<system_clock> time_point;	31	typedef chrono::time_point<system_clock> time_point;
32	static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;	32	static _LIBCPP_CONSTEXPR_SINCE_CXX14 const bool is_steady = false;
33		33
34	static time_point now() _NOEXCEPT;	34	[[__nodiscard__]] static time_point now() _NOEXCEPT;
35	static time_t to_time_t(const time_point& __t) _NOEXCEPT;	35	[[__nodiscard__]] static time_t to_time_t(const time_point& __t) _NOEXCEPT;
36	static time_point from_time_t(time_t __t) _NOEXCEPT;	36	[[__nodiscard__]] static time_point from_time_t(time_t __t) _NOEXCEPT;
37	};	37	};
38		38
39	#if _LIBCPP_STD_VER >= 20	39	#if _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/time_point.h+37-13

 @@ -14,6 +14,8 @@
 #include <__compare/ordering.h>
 #include <__compare/three_way_comparable.h>
 #include <__config>
+#include <__cstddef/size_t.h>
+#include <__functional/hash.h>
 #include <__type_traits/common_type.h>
 #include <__type_traits/enable_if.h>
 #include <__type_traits/is_convertible.h>
 @@ -54,7 +56,9 @@ public:
   // observer
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 duration time_since_epoch() const { return __d_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 duration time_since_epoch() const {
+    return __d_;
+  }
   // arithmetic
 @@ -82,8 +86,12 @@ public:
   // special values
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT { return time_point(duration::min()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR time_point min() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT { return time_point(duration::max()); }
+    return time_point(duration::min());
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR time_point max() _NOEXCEPT {
+    return time_point(duration::max());
+  }
 };
 } // namespace chrono
 @@ -95,30 +103,33 @@ struct common_type<chrono::time_point<_Clock, _Duration1>, chrono::time_point<_C
 namespace chrono {
-template <class _ToDuration, class _Clock, class _Duration>
+template <class _ToDuration, class _Clock, class _Duration, __enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, _ToDuration>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, _ToDuration>
 time_point_cast(const time_point<_Clock, _Duration>& __t) {
   return time_point<_Clock, _ToDuration>(chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 }
 #if _LIBCPP_STD_VER >= 17
 template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> floor(const time_point<_Clock, _Duration>& __t) {
+[[nodiscard]] inline
+    _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> floor(const time_point<_Clock, _Duration>& __t) {
   return time_point<_Clock, _ToDuration>{chrono::floor<_ToDuration>(__t.time_since_epoch())};
 }
 template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> ceil(const time_point<_Clock, _Duration>& __t) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration>
+ceil(const time_point<_Clock, _Duration>& __t) {
   return time_point<_Clock, _ToDuration>{chrono::ceil<_ToDuration>(__t.time_since_epoch())};
 }
 template <class _ToDuration, class _Clock, class _Duration, enable_if_t<__is_duration_v<_ToDuration>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration> round(const time_point<_Clock, _Duration>& __t) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr time_point<_Clock, _ToDuration>
+round(const time_point<_Clock, _Duration>& __t) {
   return time_point<_Clock, _ToDuration>{chrono::round<_ToDuration>(__t.time_since_epoch())};
 }
 template <class _Rep, class _Period, enable_if_t<numeric_limits<_Rep>::is_signed, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI constexpr duration<_Rep, _Period> abs(duration<_Rep, _Period> __d) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr duration<_Rep, _Period> abs(duration<_Rep, _Period> __d) {
   return __d >= __d.zero() ? +__d : -__d;
 }
 #endif // _LIBCPP_STD_VER >= 17
 @@ -188,7 +199,7 @@ operator<=>(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock
 // time_point operator+(time_point x, duration y);
 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
 operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
   typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Tr;
 @@ -198,7 +209,7 @@ operator+(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Pe
 // time_point operator+(duration x, time_point y);
 template <class _Rep1, class _Period1, class _Clock, class _Duration2>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, typename common_type<duration<_Rep1, _Period1>, _Duration2>::type>
 operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
   return __rhs + __lhs;
 @@ -207,7 +218,7 @@ operator+(const duration<_Rep1, _Period1>& __lhs, const time_point<_Clock, _Dura
 // time_point operator-(time_point x, duration y);
 template <class _Clock, class _Duration1, class _Rep2, class _Period2>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 _LIBCPP_CONSTEXPR_SINCE_CXX14 time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type>
 operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Period2>& __rhs) {
   typedef time_point<_Clock, typename common_type<_Duration1, duration<_Rep2, _Period2> >::type> _Ret;
 @@ -217,13 +228,26 @@ operator-(const time_point<_Clock, _Duration1>& __lhs, const duration<_Rep2, _Pe
 // duration operator-(time_point x, time_point y);
 template <class _Clock, class _Duration1, class _Duration2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename common_type<_Duration1, _Duration2>::type
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+typename common_type<_Duration1, _Duration2>::type
 operator-(const time_point<_Clock, _Duration1>& __lhs, const time_point<_Clock, _Duration2>& __rhs) {
   return __lhs.time_since_epoch() - __rhs.time_since_epoch();
 }
 } // namespace chrono
+#if _LIBCPP_STD_VER >= 26
+template <class _Clock, class _Duration>
+  requires __has_enabled_hash<_Duration>::value
+struct hash<chrono::time_point<_Clock, _Duration>> {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::time_point<_Clock, _Duration>& __tp) {
+    return hash<_Duration>{}(__tp.time_since_epoch());
+  }
+};
+#endif // _LIBCPP_STD_VER >= 26
 _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_POP_MACROS

lib/libcxx/include/__chrono/weekday.h+25

...	@@ -15,6 +15,8 @@	...	@@ -15,6 +15,8 @@
15	#include <__chrono/system_clock.h>	15	#include <__chrono/system_clock.h>
16	#include <__chrono/time_point.h>	16	#include <__chrono/time_point.h>
17	#include <__config>	17	#include <__config>
		18	#include <__cstddef/size_t.h>
		19	#include <__functional/hash.h>
18		20
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header	22	# pragma GCC system_header
...	@@ -160,6 +162,29 @@ inline constexpr weekday Saturday{6};	...	@@ -160,6 +162,29 @@ inline constexpr weekday Saturday{6};
160		162
161	} // namespace chrono	163	} // namespace chrono
162		164
		165	# if _LIBCPP_STD_VER >= 26
		166
		167	template <>
		168	struct hash<chrono::weekday> {
		169	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::weekday& __w) noexcept { return __w.c_encoding(); }
		170	};
		171
		172	template <>
		173	struct hash<chrono::weekday_indexed> {
		174	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::weekday_indexed& __wi) noexcept {
		175	return std::__hash_combine(hash<chrono::weekday>{}(__wi.weekday()), __wi.index());
		176	}
		177	};
		178
		179	template <>
		180	struct hash<chrono::weekday_last> {
		181	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::weekday_last& __wl) noexcept {
		182	return hash<chrono::weekday>{}(__wl.weekday());
		183	}
		184	};
		185
		186	# endif // _LIBCPP_STD_VER >= 26
		187
163	_LIBCPP_END_NAMESPACE_STD	188	_LIBCPP_END_NAMESPACE_STD
164		189
165	#endif // _LIBCPP_STD_VER >= 20	190	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/year.h+11

...	@@ -13,6 +13,8 @@	...	@@ -13,6 +13,8 @@
13	#include <__chrono/duration.h>	13	#include <__chrono/duration.h>
14	#include <__compare/ordering.h>	14	#include <__compare/ordering.h>
15	#include <__config>	15	#include <__config>
		16	#include <__cstddef/size_t.h>
		17	#include <__functional/hash.h>
16	#include <limits>	18	#include <limits>
17		19
18	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	20	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -109,6 +111,15 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool year::ok() const noexcept {	...	@@ -109,6 +111,15 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool year::ok() const noexcept {
109		111
110	} // namespace chrono	112	} // namespace chrono
111		113
		114	# if _LIBCPP_STD_VER >= 26
		115
		116	template <>
		117	struct hash<chrono::year> {
		118	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::year& __y) noexcept { return static_cast<int>(__y); }
		119	};
		120
		121	# endif // _LIBCPP_STD_VER >= 26
		122
112	_LIBCPP_END_NAMESPACE_STD	123	_LIBCPP_END_NAMESPACE_STD
113		124
114	#endif // _LIBCPP_STD_VER >= 20	125	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/year_month.h+13

...	@@ -15,6 +15,8 @@	...	@@ -15,6 +15,8 @@
15	#include <__chrono/year.h>	15	#include <__chrono/year.h>
16	#include <__compare/ordering.h>	16	#include <__compare/ordering.h>
17	#include <__config>	17	#include <__config>
		18	#include <__cstddef/size_t.h>
		19	#include <__functional/hash.h>
18		20
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header	22	# pragma GCC system_header
...	@@ -116,6 +118,17 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& year_month::operator-=(const	...	@@ -116,6 +118,17 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr year_month& year_month::operator-=(const
116		118
117	} // namespace chrono	119	} // namespace chrono
118		120
		121	# if _LIBCPP_STD_VER >= 26
		122
		123	template <>
		124	struct hash<chrono::year_month> {
		125	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::year_month& __ym) noexcept {
		126	return std::__hash_combine(hash<chrono::year>{}(__ym.year()), hash<chrono::month>{}(__ym.month()));
		127	}
		128	};
		129
		130	# endif // _LIBCPP_STD_VER >= 26
		131
119	_LIBCPP_END_NAMESPACE_STD	132	_LIBCPP_END_NAMESPACE_STD
120		133
121	#endif // _LIBCPP_STD_VER >= 20	134	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/year_month_day.h+23

...	@@ -21,6 +21,8 @@	...	@@ -21,6 +21,8 @@
21	#include <__chrono/year_month.h>	21	#include <__chrono/year_month.h>
22	#include <__compare/ordering.h>	22	#include <__compare/ordering.h>
23	#include <__config>	23	#include <__config>
		24	#include <__cstddef/size_t.h>
		25	#include <__functional/hash.h>
24	#include <limits>	26	#include <limits>
25		27
26	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	28	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -330,6 +332,27 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr bool year_month_day::ok() const noexcept	...	@@ -330,6 +332,27 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr bool year_month_day::ok() const noexcept
330		332
331	} // namespace chrono	333	} // namespace chrono
332		334
		335	# if _LIBCPP_STD_VER >= 26
		336
		337	template <>
		338	struct hash<chrono::year_month_day> {
		339	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::year_month_day& __ymd) noexcept {
		340	return std::__hash_combine(
		341	hash<chrono::year>{}(__ymd.year()),
		342	std::__hash_combine(hash<chrono::month>{}(__ymd.month()), hash<chrono::day>{}(__ymd.day())));
		343	}
		344	};
		345
		346	template <>
		347	struct hash<chrono::year_month_day_last> {
		348	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::year_month_day_last& __ymdl) noexcept {
		349	return std::__hash_combine(
		350	hash<chrono::year>{}(__ymdl.year()), hash<chrono::month_day_last>{}(__ymdl.month_day_last()));
		351	}
		352	};
		353
		354	# endif // _LIBCPP_STD_VER >= 26
		355
333	_LIBCPP_END_NAMESPACE_STD	356	_LIBCPP_END_NAMESPACE_STD
334		357
335	#endif // _LIBCPP_STD_VER >= 20	358	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/year_month_weekday.h+26

...	@@ -22,6 +22,8 @@	...	@@ -22,6 +22,8 @@
22	#include <__chrono/year_month.h>	22	#include <__chrono/year_month.h>
23	#include <__chrono/year_month_day.h>	23	#include <__chrono/year_month_day.h>
24	#include <__config>	24	#include <__config>
		25	#include <__cstddef/size_t.h>
		26	#include <__functional/hash.h>
25		27
26	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	28	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
27	# pragma GCC system_header	29	# pragma GCC system_header
...	@@ -280,6 +282,30 @@ year_month_weekday_last::operator-=(const years& __dy) noexcept {	...	@@ -280,6 +282,30 @@ year_month_weekday_last::operator-=(const years& __dy) noexcept {
280		282
281	} // namespace chrono	283	} // namespace chrono
282		284
		285	# if _LIBCPP_STD_VER >= 26
		286
		287	template <>
		288	struct hash<chrono::year_month_weekday> {
		289	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::year_month_weekday& __ymw) noexcept {
		290	return std::__hash_combine(
		291	hash<chrono::year>{}(__ymw.year()),
		292	std::__hash_combine(
		293	hash<chrono::month>{}(__ymw.month()), hash<chrono::weekday_indexed>{}(__ymw.weekday_indexed())));
		294	}
		295	};
		296
		297	template <>
		298	struct hash<chrono::year_month_weekday_last> {
		299	_LIBCPP_HIDE_FROM_ABI static size_t operator()(const chrono::year_month_weekday_last& __ymwl) noexcept {
		300	return std::__hash_combine(
		301	hash<chrono::year>{}(__ymwl.year()),
		302	std::__hash_combine(
		303	hash<chrono::month>{}(__ymwl.month()), hash<chrono::weekday_last>{}(__ymwl.weekday_last())));
		304	}
		305	};
		306
		307	# endif // _LIBCPP_STD_VER >= 26
		308
283	_LIBCPP_END_NAMESPACE_STD	309	_LIBCPP_END_NAMESPACE_STD
284		310
285	#endif // _LIBCPP_STD_VER >= 20	311	#endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__chrono/zoned_time.h+16

...	@@ -24,6 +24,8 @@	...	@@ -24,6 +24,8 @@
24	# include <__chrono/tzdb_list.h>	24	# include <__chrono/tzdb_list.h>
25	# include <__concepts/constructible.h>	25	# include <__concepts/constructible.h>
26	# include <__config>	26	# include <__config>
		27	# include <__cstddef/size_t.h>
		28	# include <__functional/hash.h>
27	# include <__type_traits/common_type.h>	29	# include <__type_traits/common_type.h>
28	# include <__type_traits/conditional.h>	30	# include <__type_traits/conditional.h>
29	# include <__type_traits/remove_cvref.h>	31	# include <__type_traits/remove_cvref.h>
...	@@ -216,6 +218,20 @@ operator==(const zoned_time<_Duration1, _TimeZonePtr>& __lhs, const zoned_time<_	...	@@ -216,6 +218,20 @@ operator==(const zoned_time<_Duration1, _TimeZonePtr>& __lhs, const zoned_time<_
216		218
217	} // namespace chrono	219	} // namespace chrono
218		220
		221	# if _LIBCPP_STD_VER >= 26
		222
		223	template <class _Duration, class _TimeZonePtr>
		224	requires __has_enabled_hash<_Duration>::value && __has_enabled_hash<_TimeZonePtr>::value
		225	struct hash<chrono::zoned_time<_Duration, _TimeZonePtr>> {
		226	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static size_t
		227	operator()(const chrono::zoned_time<_Duration, _TimeZonePtr>& __zt) {
		228	return std::__hash_combine(
		229	hash<chrono::sys_time<_Duration>>{}(__zt.get_sys_time()), hash<_TimeZonePtr>{}(__zt.get_time_zone()));
		230	}
		231	};
		232
		233	# endif // _LIBCPP_STD_VER >= 26
		234
219	# endif // _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM &&	235	# endif // _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_TIME_ZONE_DATABASE && _LIBCPP_HAS_FILESYSTEM &&
220	// _LIBCPP_HAS_LOCALIZATION	236	// _LIBCPP_HAS_LOCALIZATION
221		237

lib/libcxx/include/__compare/is_eq.h+6-6

...	@@ -20,12 +20,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -20,12 +20,12 @@ _LIBCPP_BEGIN_NAMESPACE_STD
20		20
21	#if _LIBCPP_STD_VER >= 20	21	#if _LIBCPP_STD_VER >= 20
22		22
23	_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_eq(partial_ordering __c) noexcept { return __c == 0; }	23	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_eq(partial_ordering __c) noexcept { return __c == 0; }
24	_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_neq(partial_ordering __c) noexcept { return __c != 0; }	24	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_neq(partial_ordering __c) noexcept { return __c != 0; }
25	_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lt(partial_ordering __c) noexcept { return __c < 0; }	25	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lt(partial_ordering __c) noexcept { return __c < 0; }
26	_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lteq(partial_ordering __c) noexcept { return __c <= 0; }	26	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_lteq(partial_ordering __c) noexcept { return __c <= 0; }
27	_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gt(partial_ordering __c) noexcept { return __c > 0; }	27	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gt(partial_ordering __c) noexcept { return __c > 0; }
28	_LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gteq(partial_ordering __c) noexcept { return __c >= 0; }	28	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr bool is_gteq(partial_ordering __c) noexcept { return __c >= 0; }
29		29
30	#endif // _LIBCPP_STD_VER >= 20	30	#endif // _LIBCPP_STD_VER >= 20
31		31

lib/libcxx/include/__compare/strong_order.h+12-30

 @@ -13,7 +13,6 @@
 #include <__compare/compare_three_way.h>
 #include <__compare/ordering.h>
 #include <__config>
-#include <__math/exponential_functions.h>
 #include <__math/traits.h>
 #include <__type_traits/conditional.h>
 #include <__type_traits/decay.h>
 @@ -53,38 +52,21 @@ struct __fn {
   template <class _Tp, class _Up, class _Dp = decay_t<_Tp>>
     requires is_same_v<_Dp, decay_t<_Up>> && is_floating_point_v<_Dp>
   _LIBCPP_HIDE_FROM_ABI static constexpr strong_ordering __go(_Tp&& __t, _Up&& __u, __priority_tag<1>) noexcept {
-    if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int32_t)) {
+    if constexpr (numeric_limits<_Dp>::is_iec559 &&
-      int32_t __rx = std::bit_cast<int32_t>(__t);
+                  (sizeof(_Dp) == sizeof(int32_t) || sizeof(_Dp) == sizeof(int64_t))) {
-      int32_t __ry = std::bit_cast<int32_t>(__u);
+      using _IntT = conditional_t<sizeof(_Dp) == sizeof(int32_t), int32_t, int64_t>;
-      __rx         = (__rx < 0) ? (numeric_limits<int32_t>::min() - __rx - 1) : __rx;
+      _IntT __rx  = std::bit_cast<_IntT>(__t);
-      __ry         = (__ry < 0) ? (numeric_limits<int32_t>::min() - __ry - 1) : __ry;
+      _IntT __ry  = std::bit_cast<_IntT>(__u);
-      return (__rx <=> __ry);
+      __rx        = (__rx < 0) ? (numeric_limits<_IntT>::min() - __rx - 1) : __rx;
-    } else if constexpr (numeric_limits<_Dp>::is_iec559 && sizeof(_Dp) == sizeof(int64_t)) {
+      __ry        = (__ry < 0) ? (numeric_limits<_IntT>::min() - __ry - 1) : __ry;
-      int64_t __rx = std::bit_cast<int64_t>(__t);
-      int64_t __ry = std::bit_cast<int64_t>(__u);
-      __rx         = (__rx < 0) ? (numeric_limits<int64_t>::min() - __rx - 1) : __rx;
-      __ry         = (__ry < 0) ? (numeric_limits<int64_t>::min() - __ry - 1) : __ry;
       return (__rx <=> __ry);
     } else if (__t < __u) {
       return strong_ordering::less;
     } else if (__t > __u) {
       return strong_ordering::greater;
     } else if (__t == __u) {
-      if constexpr (numeric_limits<_Dp>::radix == 2) {
+      static_assert(numeric_limits<_Dp>::radix == 2, "floating point type with a radix other than 2?");
-        return __math::signbit(__u) <=> __math::signbit(__t);
+      return __math::signbit(__u) <=> __math::signbit(__t);
-      } else {
-        // This is bullet 3 of the IEEE754 algorithm, relevant
-        // only for decimal floating-point;
-        // see https://stackoverflow.com/questions/69068075/
-        if (__t == 0 || __math::isinf(__t)) {
-          return __math::signbit(__u) <=> __math::signbit(__t);
-        } else {
-          int __texp, __uexp;
-          (void)__math::frexp(__t, &__texp);
-          (void)__math::frexp(__u, &__uexp);
-          return (__t < 0) ? (__texp <=> __uexp) : (__uexp <=> __texp);
-        }
-      }
     } else {
       // They're unordered, so one of them must be a NAN.
       // The order is -QNAN, -SNAN, numbers, +SNAN, +QNAN.
 @@ -93,9 +75,9 @@ struct __fn {
       bool __t_is_negative = __math::signbit(__t);
       bool __u_is_negative = __math::signbit(__u);
       using _IntType =
-          conditional_t< sizeof(__t) == sizeof(int32_t),
+          conditional_t<sizeof(__t) == sizeof(int32_t),
-                         int32_t,
+                        int32_t,
-                         conditional_t< sizeof(__t) == sizeof(int64_t), int64_t, void> >;
+                        conditional_t<sizeof(__t) == sizeof(int64_t), int64_t, void>>;
       if constexpr (is_same_v<_IntType, void>) {
         static_assert(sizeof(_Dp) == 0, "std::strong_order is unimplemented for this floating-point type");
       } else if (__t_is_nan && __u_is_nan) {

lib/libcxx/include/__compare/three_way_comparable.h+2-2

lib/libcxx/include/__concepts/comparison_common_type.h created+40

...	@@ -0,0 +1,40 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
10	#define _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H
11
12	#include <__concepts/convertible_to.h>
13	#include <__concepts/same_as.h>
14	#include <__config>
15	#include <__type_traits/common_reference.h>
16	#include <__type_traits/remove_cvref.h>
17
18	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
19	# pragma GCC system_header
20	#endif
21
22	_LIBCPP_BEGIN_NAMESPACE_STD
23
24	#if _LIBCPP_STD_VER >= 20
25
26	template <class _Tp, class _Up, class _CommonRef = common_reference_t<const _Tp&, const _Up&>>
27	concept __comparison_common_type_with_impl =
28	same_as<common_reference_t<const _Tp&, const _Up&>, common_reference_t<const _Up&, const _Tp&>> && requires {
29	requires convertible_to<const _Tp&, const _CommonRef&> \|\| convertible_to<_Tp, const _CommonRef&>;
30	requires convertible_to<const _Up&, const _CommonRef&> \|\| convertible_to<_Up, const _CommonRef&>;
31	};
32
33	template <class _Tp, class _Up>
34	concept __comparison_common_type_with = __comparison_common_type_with_impl<remove_cvref_t<_Tp>, remove_cvref_t<_Up>>;
35
36	#endif // _LIBCPP_STD_VER >= 20
37
38	_LIBCPP_END_NAMESPACE_STD
39
40	#endif // _LIBCPP___CONCEPTS_COMPARISON_COMMON_TYPE_H

lib/libcxx/include/__concepts/equality_comparable.h+2-1

...	@@ -11,6 +11,7 @@	...	@@ -11,6 +11,7 @@
11		11
12	#include <__concepts/boolean_testable.h>	12	#include <__concepts/boolean_testable.h>
13	#include <__concepts/common_reference_with.h>	13	#include <__concepts/common_reference_with.h>
		14	#include <__concepts/comparison_common_type.h>
14	#include <__config>	15	#include <__config>
15	#include <__type_traits/common_reference.h>	16	#include <__type_traits/common_reference.h>
16	#include <__type_traits/make_const_lvalue_ref.h>	17	#include <__type_traits/make_const_lvalue_ref.h>
...	@@ -41,7 +42,7 @@ concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;	...	@@ -41,7 +42,7 @@ concept equality_comparable = __weakly_equality_comparable_with<_Tp, _Tp>;
41	template <class _Tp, class _Up>	42	template <class _Tp, class _Up>
42	concept equality_comparable_with =	43	concept equality_comparable_with =
43	equality_comparable<_Tp> && equality_comparable<_Up> &&	44	equality_comparable<_Tp> && equality_comparable<_Up> &&
44	common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&	45	__comparison_common_type_with<_Tp, _Up> &&
45	equality_comparable<	46	equality_comparable<
46	common_reference_t<	47	common_reference_t<
47	__make_const_lvalue_ref<_Tp>,	48	__make_const_lvalue_ref<_Tp>,

lib/libcxx/include/__condition_variable/condition_variable.h+1-1

...	@@ -170,7 +170,7 @@ public:	...	@@ -170,7 +170,7 @@ public:
170	wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);	170	wait_for(unique_lock<mutex>& __lk, const chrono::duration<_Rep, _Period>& __d, _Predicate __pred);
171		171
172	typedef __libcpp_condvar_t* native_handle_type;	172	typedef __libcpp_condvar_t* native_handle_type;
173	_LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__cv_; }	173	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__cv_; }
174		174
175	private:	175	private:
176	void	176	void

lib/libcxx/include/__config+63-280

...	@@ -14,6 +14,8 @@	...	@@ -14,6 +14,8 @@
14	#include <__configuration/abi.h>	14	#include <__configuration/abi.h>
15	#include <__configuration/availability.h>	15	#include <__configuration/availability.h>
16	#include <__configuration/compiler.h>	16	#include <__configuration/compiler.h>
		17	#include <__configuration/experimental.h>
		18	#include <__configuration/hardening.h>
17	#include <__configuration/language.h>	19	#include <__configuration/language.h>
18	#include <__configuration/platform.h>	20	#include <__configuration/platform.h>
19		21
...	@@ -28,7 +30,7 @@	...	@@ -28,7 +30,7 @@
28	// _LIBCPP_VERSION represents the version of libc++, which matches the version of LLVM.	30	// _LIBCPP_VERSION represents the version of libc++, which matches the version of LLVM.
29	// Given a LLVM release LLVM XX.YY.ZZ (e.g. LLVM 17.0.1 == 17.00.01), _LIBCPP_VERSION is	31	// Given a LLVM release LLVM XX.YY.ZZ (e.g. LLVM 17.0.1 == 17.00.01), _LIBCPP_VERSION is
30	// defined to XXYYZZ.	32	// defined to XXYYZZ.
31	# define _LIBCPP_VERSION 210100	33	# define _LIBCPP_VERSION 220104
32		34
33	# define _LIBCPP_CONCAT_IMPL(_X, _Y) _X##_Y	35	# define _LIBCPP_CONCAT_IMPL(_X, _Y) _X##_Y
34	# define _LIBCPP_CONCAT(_X, _Y) _LIBCPP_CONCAT_IMPL(_X, _Y)	36	# define _LIBCPP_CONCAT(_X, _Y) _LIBCPP_CONCAT_IMPL(_X, _Y)
...	@@ -38,195 +40,6 @@	...	@@ -38,195 +40,6 @@
38	# define _LIBCPP_FREESTANDING	40	# define _LIBCPP_FREESTANDING
39	# endif	41	# endif
40		42
41	// NOLINTNEXTLINE(libcpp-cpp-version-check)
42	# if __cplusplus < 201103L
43	# define _LIBCPP_CXX03_LANG
44	# endif
45
46	# if __has_feature(experimental_library)
47	# ifndef _LIBCPP_ENABLE_EXPERIMENTAL
48	# define _LIBCPP_ENABLE_EXPERIMENTAL
49	# endif
50	# endif
51
52	// Incomplete features get their own specific disabling flags. This makes it
53	// easier to grep for target specific flags once the feature is complete.
54	# if defined(_LIBCPP_ENABLE_EXPERIMENTAL) \|\| defined(_LIBCPP_BUILDING_LIBRARY)
55	# define _LIBCPP_HAS_EXPERIMENTAL_LIBRARY 1
56	# else
57	# define _LIBCPP_HAS_EXPERIMENTAL_LIBRARY 0
58	# endif
59
60	# define _LIBCPP_HAS_EXPERIMENTAL_PSTL _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
61	# define _LIBCPP_HAS_EXPERIMENTAL_TZDB _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
62	# define _LIBCPP_HAS_EXPERIMENTAL_SYNCSTREAM _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
63	# define _LIBCPP_HAS_EXPERIMENTAL_HARDENING_OBSERVE_SEMANTIC _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
64
65	// HARDENING {
66
67	// TODO(LLVM 23): Remove this. We're making these an error to catch folks who might not have migrated.
68	// Since hardening went through several changes (many of which impacted user-facing macros),
69	// we're keeping these checks around for a bit longer than usual. Failure to properly configure
70	// hardening results in checks being dropped silently, which is a pretty big deal.
71	# if defined(_LIBCPP_ENABLE_ASSERTIONS)
72	# error "_LIBCPP_ENABLE_ASSERTIONS has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
73	# endif
74	# if defined(_LIBCPP_ENABLE_HARDENED_MODE)
75	# error "_LIBCPP_ENABLE_HARDENED_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
76	# endif
77	# if defined(_LIBCPP_ENABLE_SAFE_MODE)
78	# error "_LIBCPP_ENABLE_SAFE_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
79	# endif
80	# if defined(_LIBCPP_ENABLE_DEBUG_MODE)
81	# error "_LIBCPP_ENABLE_DEBUG_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
82	# endif
83
84	// The library provides the macro `_LIBCPP_HARDENING_MODE` which can be set to one of the following values:
85	//
86	// - `_LIBCPP_HARDENING_MODE_NONE`;
87	// - `_LIBCPP_HARDENING_MODE_FAST`;
88	// - `_LIBCPP_HARDENING_MODE_EXTENSIVE`;
89	// - `_LIBCPP_HARDENING_MODE_DEBUG`.
90	//
91	// These values have the following effects:
92	//
93	// - `_LIBCPP_HARDENING_MODE_NONE` -- sets the hardening mode to "none" which disables all runtime hardening checks;
94	//
95	// - `_LIBCPP_HARDENING_MODE_FAST` -- sets that hardening mode to "fast". The fast mode enables security-critical checks
96	// that can be done with relatively little runtime overhead in constant time;
97	//
98	// - `_LIBCPP_HARDENING_MODE_EXTENSIVE` -- sets the hardening mode to "extensive". The extensive mode is a superset of
99	// the fast mode that additionally enables checks that are relatively cheap and prevent common types of logic errors
100	// but are not necessarily security-critical;
101	//
102	// - `_LIBCPP_HARDENING_MODE_DEBUG` -- sets the hardening mode to "debug". The debug mode is a superset of the extensive
103	// mode and enables all checks available in the library, including internal assertions. Checks that are part of the
104	// debug mode can be very expensive and thus the debug mode is intended to be used for testing, not in production.
105
106	// Inside the library, assertions are categorized so they can be cherry-picked based on the chosen hardening mode. These
107	// macros are only for internal use -- users should only pick one of the high-level hardening modes described above.
108	//
109	// - `_LIBCPP_ASSERT_VALID_INPUT_RANGE` -- checks that ranges (whether expressed as an iterator pair, an iterator and
110	// a sentinel, an iterator and a count, or a `std::range`) given as input to library functions are valid:
111	// - the sentinel is reachable from the begin iterator;
112	// - TODO(hardening): both iterators refer to the same container.
113	//
114	// - `_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS` -- checks that any attempts to access a container element, whether through
115	// the container object or through an iterator, are valid and do not attempt to go out of bounds or otherwise access
116	// a non-existent element. For iterator checks to work, bounded iterators must be enabled in the ABI. Types like
117	// `optional` and `function` are considered one-element containers for the purposes of this check.
118	//
119	// - `_LIBCPP_ASSERT_NON_NULL` -- checks that the pointer being dereferenced is not null. On most modern platforms zero
120	// address does not refer to an actual location in memory, so a null pointer dereference would not compromize the
121	// memory security of a program (however, it is still undefined behavior that can result in strange errors due to
122	// compiler optimizations).
123	//
124	// - `_LIBCPP_ASSERT_NON_OVERLAPPING_RANGES` -- for functions that take several ranges as arguments, checks that the
125	// given ranges do not overlap.
126	//
127	// - `_LIBCPP_ASSERT_VALID_DEALLOCATION` -- checks that an attempt to deallocate memory is valid (e.g. the given object
128	// was allocated by the given allocator). Violating this category typically results in a memory leak.
129	//
130	// - `_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL` -- checks that a call to an external API doesn't fail in
131	// an unexpected manner. This includes triggering documented cases of undefined behavior in an external library (like
132	// attempting to unlock an unlocked mutex in pthreads). Any API external to the library falls under this category
133	// (from system calls to compiler intrinsics). We generally don't expect these failures to compromize memory safety or
134	// otherwise create an immediate security issue.
135	//
136	// - `_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR` -- checks any operations that exchange nodes between containers to make sure
137	// the containers have compatible allocators.
138	//
139	// - `_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN` -- checks that the given argument is within the domain of valid arguments
140	// for the function. Violating this typically produces an incorrect result (e.g. the clamp algorithm returns the
141	// original value without clamping it due to incorrect functors) or puts an object into an invalid state (e.g.
142	// a string view where only a subset of elements is possible to access). This category is for assertions violating
143	// which doesn't cause any immediate issues in the library -- whatever the consequences are, they will happen in the
144	// user code.
145	//
146	// - `_LIBCPP_ASSERT_PEDANTIC` -- checks prerequisites which are imposed by the Standard, but violating which happens to
147	// be benign in our implementation.
148	//
149	// - `_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT` -- checks that the given argument satisfies the semantic requirements imposed
150	// by the Standard. Typically, there is no simple way to completely prove that a semantic requirement is satisfied;
151	// thus, this would often be a heuristic check and it might be quite expensive.
152	//
153	// - `_LIBCPP_ASSERT_INTERNAL` -- checks that internal invariants of the library hold. These assertions don't depend on
154	// user input.
155	//
156	// - `_LIBCPP_ASSERT_UNCATEGORIZED` -- for assertions that haven't been properly classified yet.
157
158	// clang-format off
159	# define _LIBCPP_HARDENING_MODE_NONE (1 << 1)
160	# define _LIBCPP_HARDENING_MODE_FAST (1 << 2)
161	# define _LIBCPP_HARDENING_MODE_EXTENSIVE (1 << 4) // Deliberately not ordered.
162	# define _LIBCPP_HARDENING_MODE_DEBUG (1 << 3)
163	// clang-format on
164
165	# ifndef _LIBCPP_HARDENING_MODE
166
167	# ifndef _LIBCPP_HARDENING_MODE_DEFAULT
168	# error _LIBCPP_HARDENING_MODE_DEFAULT is not defined. This definition should be set at configuration time in the \
169	`__config_site` header, please make sure your installation of libc++ is not broken.
170	# endif
171
172	# define _LIBCPP_HARDENING_MODE _LIBCPP_HARDENING_MODE_DEFAULT
173	# endif
174
175	# if _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_NONE && \
176	_LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_FAST && \
177	_LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_EXTENSIVE && \
178	_LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_DEBUG
179	# error _LIBCPP_HARDENING_MODE must be set to one of the following values: \
180	_LIBCPP_HARDENING_MODE_NONE, \
181	_LIBCPP_HARDENING_MODE_FAST, \
182	_LIBCPP_HARDENING_MODE_EXTENSIVE, \
183	_LIBCPP_HARDENING_MODE_DEBUG
184	# endif
185
186	// Hardening assertion semantics generally mirror the evaluation semantics of C++26 Contracts:
187	// - `ignore` evaluates the assertion but doesn't do anything if it fails (note that it differs from the Contracts
188	// `ignore` semantic which wouldn't evaluate the assertion at all);
189	// - `observe` logs an error (indicating, if possible, that the error is fatal) and continues execution;
190	// - `quick-enforce` terminates the program as fast as possible (via trapping);
191	// - `enforce` logs an error and then terminates the program.
192	//
193	// Notes:
194	// - Continuing execution after a hardening check fails results in undefined behavior; the `observe` semantic is meant
195	// to make adopting hardening easier but should not be used outside of this scenario;
196	// - C++26 wording for Library Hardening precludes a conforming Hardened implementation from using the Contracts
197	// `ignore` semantic when evaluating hardened preconditions in the Library. Libc++ allows using this semantic for
198	// hardened preconditions, however, be aware that using `ignore` does not produce a conforming "Hardened"
199	// implementation, unlike the other semantics above.
200	// clang-format off
201	# define _LIBCPP_ASSERTION_SEMANTIC_IGNORE (1 << 1)
202	# define _LIBCPP_ASSERTION_SEMANTIC_OBSERVE (1 << 2)
203	# define _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE (1 << 3)
204	# define _LIBCPP_ASSERTION_SEMANTIC_ENFORCE (1 << 4)
205	// clang-format on
206
207	// Allow users to define an arbitrary assertion semantic; otherwise, use the default mapping from modes to semantics.
208	// The default is for production-capable modes to use `quick-enforce` (i.e., trap) and for the `debug` mode to use
209	// `enforce` (i.e., log and abort).
210	# ifndef _LIBCPP_ASSERTION_SEMANTIC
211
212	# if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
213	# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_ENFORCE
214	# else
215	# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE
216	# endif
217
218	# else
219	# if !_LIBCPP_HAS_EXPERIMENTAL_LIBRARY
220	# error "Assertion semantics are an experimental feature."
221	# endif
222	# if defined(_LIBCPP_CXX03_LANG)
223	# error "Assertion semantics are not available in the C++03 mode."
224	# endif
225
226	# endif // _LIBCPP_ASSERTION_SEMANTIC
227
228	// } HARDENING
229
230	# define _LIBCPP_TOSTRING2(x) #x	43	# define _LIBCPP_TOSTRING2(x) #x
231	# define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)	44	# define _LIBCPP_TOSTRING(x) _LIBCPP_TOSTRING2(x)
232		45
...	@@ -320,13 +133,6 @@ _LIBCPP_HARDENING_MODE_DEBUG	...	@@ -320,13 +133,6 @@ _LIBCPP_HARDENING_MODE_DEBUG
320	// When this option is used, the token passed to `std::random_device`'s	133	// When this option is used, the token passed to `std::random_device`'s
321	// constructor must be "/dev/urandom" -- anything else is an error.	134	// constructor must be "/dev/urandom" -- anything else is an error.
322	//	135	//
323	// _LIBCPP_USING_NACL_RANDOM
324	// NaCl's sandbox (which PNaCl also runs in) doesn't allow filesystem access,
325	// including accesses to the special files under `/dev`. This implementation
326	// uses the NaCL syscall `nacl_secure_random_init()` to get entropy.
327	// When this option is used, the token passed to `std::random_device`'s
328	// constructor must be "/dev/urandom" -- anything else is an error.
329	//
330	// _LIBCPP_USING_WIN32_RANDOM	136	// _LIBCPP_USING_WIN32_RANDOM
331	// Use rand_s(), for use on Windows.	137	// Use rand_s(), for use on Windows.
332	// When this option is used, the token passed to `std::random_device`'s	138	// When this option is used, the token passed to `std::random_device`'s
...	@@ -338,8 +144,6 @@ _LIBCPP_HARDENING_MODE_DEBUG	...	@@ -338,8 +144,6 @@ _LIBCPP_HARDENING_MODE_DEBUG
338	# define _LIBCPP_USING_GETENTROPY	144	# define _LIBCPP_USING_GETENTROPY
339	# elif defined(__Fuchsia__)	145	# elif defined(__Fuchsia__)
340	# define _LIBCPP_USING_FUCHSIA_CPRNG	146	# define _LIBCPP_USING_FUCHSIA_CPRNG
341	# elif defined(__native_client__)
342	# define _LIBCPP_USING_NACL_RANDOM
343	# elif defined(_LIBCPP_WIN32API)	147	# elif defined(_LIBCPP_WIN32API)
344	# define _LIBCPP_USING_WIN32_RANDOM	148	# define _LIBCPP_USING_WIN32_RANDOM
345	# else	149	# else
...	@@ -348,7 +152,7 @@ _LIBCPP_HARDENING_MODE_DEBUG	...	@@ -348,7 +152,7 @@ _LIBCPP_HARDENING_MODE_DEBUG
348		152
349	# ifndef _LIBCPP_CXX03_LANG	153	# ifndef _LIBCPP_CXX03_LANG
350		154
351	# define _LIBCPP_ALIGNOF(_Tp) alignof(_Tp)	155	# define _LIBCPP_ALIGNOF(...) alignof(__VA_ARGS__)
352	# define _ALIGNAS_TYPE(x) alignas(x)	156	# define _ALIGNAS_TYPE(x) alignas(x)
353	# define _ALIGNAS(x) alignas(x)	157	# define _ALIGNAS(x) alignas(x)
354	# define _NOEXCEPT noexcept	158	# define _NOEXCEPT noexcept
...	@@ -357,7 +161,7 @@ _LIBCPP_HARDENING_MODE_DEBUG	...	@@ -357,7 +161,7 @@ _LIBCPP_HARDENING_MODE_DEBUG
357		161
358	# else	162	# else
359		163
360	# define _LIBCPP_ALIGNOF(_Tp) _Alignof(_Tp)	164	# define _LIBCPP_ALIGNOF(...) _Alignof(__VA_ARGS__)
361	# define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))	165	# define _ALIGNAS_TYPE(x) __attribute__((__aligned__(_LIBCPP_ALIGNOF(x))))
362	# define _ALIGNAS(x) __attribute__((__aligned__(x)))	166	# define _ALIGNAS(x) __attribute__((__aligned__(x)))
363	# define nullptr __nullptr	167	# define nullptr __nullptr
...	@@ -471,6 +275,12 @@ typedef __char32_t char32_t;	...	@@ -471,6 +275,12 @@ typedef __char32_t char32_t;
471	# define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str)	275	# define _LIBCPP_GCC_DIAGNOSTIC_IGNORED(str)
472	# endif	276	# endif
473		277
		278	// Macros to enter and leave a state where deprecation warnings are suppressed.
		279	# define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
		280	_LIBCPP_DIAGNOSTIC_PUSH _LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wdeprecated") \
		281	_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wdeprecated-declarations")
		282	# define _LIBCPP_SUPPRESS_DEPRECATED_POP _LIBCPP_DIAGNOSTIC_POP
		283
474	# if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_FAST	284	# if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_FAST
475	# define _LIBCPP_HARDENING_SIG f	285	# define _LIBCPP_HARDENING_SIG f
476	# elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_EXTENSIVE	286	# elif _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_EXTENSIVE
...	@@ -481,6 +291,16 @@ typedef __char32_t char32_t;	...	@@ -481,6 +291,16 @@ typedef __char32_t char32_t;
481	# define _LIBCPP_HARDENING_SIG n // "none"	291	# define _LIBCPP_HARDENING_SIG n // "none"
482	# endif	292	# endif
483		293
		294	# if _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_OBSERVE
		295	# define _LIBCPP_ASSERTION_SEMANTIC_SIG o
		296	# elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE
		297	# define _LIBCPP_ASSERTION_SEMANTIC_SIG q
		298	# elif _LIBCPP_ASSERTION_SEMANTIC == _LIBCPP_ASSERTION_SEMANTIC_ENFORCE
		299	# define _LIBCPP_ASSERTION_SEMANTIC_SIG e
		300	# else
		301	# define _LIBCPP_ASSERTION_SEMANTIC_SIG i // `ignore`
		302	# endif
		303
484	# if !_LIBCPP_HAS_EXCEPTIONS	304	# if !_LIBCPP_HAS_EXCEPTIONS
485	# define _LIBCPP_EXCEPTIONS_SIG n	305	# define _LIBCPP_EXCEPTIONS_SIG n
486	# else	306	# else
...	@@ -488,7 +308,9 @@ typedef __char32_t char32_t;	...	@@ -488,7 +308,9 @@ typedef __char32_t char32_t;
488	# endif	308	# endif
489		309
490	# define _LIBCPP_ODR_SIGNATURE \	310	# define _LIBCPP_ODR_SIGNATURE \
491	_LIBCPP_CONCAT(_LIBCPP_CONCAT(_LIBCPP_HARDENING_SIG, _LIBCPP_EXCEPTIONS_SIG), _LIBCPP_VERSION)	311	_LIBCPP_CONCAT( \
		312	_LIBCPP_CONCAT(_LIBCPP_CONCAT(_LIBCPP_HARDENING_SIG, _LIBCPP_ASSERTION_SEMANTIC_SIG), _LIBCPP_EXCEPTIONS_SIG), \
		313	_LIBCPP_VERSION)
492		314
493	// This macro marks a symbol as being hidden from libc++'s ABI. This is achieved	315	// This macro marks a symbol as being hidden from libc++'s ABI. This is achieved
494	// on two levels:	316	// on two levels:
...	@@ -550,16 +372,6 @@ typedef __char32_t char32_t;	...	@@ -550,16 +372,6 @@ typedef __char32_t char32_t;
550	# endif	372	# endif
551	# define _LIBCPP_HIDE_FROM_ABI_VIRTUAL _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION	373	# define _LIBCPP_HIDE_FROM_ABI_VIRTUAL _LIBCPP_HIDDEN _LIBCPP_EXCLUDE_FROM_EXPLICIT_INSTANTIATION
552		374
553	# ifdef _LIBCPP_BUILDING_LIBRARY
554	# if _LIBCPP_ABI_VERSION > 1
555	# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
556	# else
557	# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1
558	# endif
559	# else
560	# define _LIBCPP_HIDE_FROM_ABI_AFTER_V1 _LIBCPP_HIDE_FROM_ABI
561	# endif
562
563	// Clang modules take a significant compile time hit when pushing and popping diagnostics.	375	// Clang modules take a significant compile time hit when pushing and popping diagnostics.
564	// Since all the headers are marked as system headers unless _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER is defined, we can	376	// Since all the headers are marked as system headers unless _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER is defined, we can
565	// simply disable this pushing and popping when _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER isn't defined.	377	// simply disable this pushing and popping when _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER isn't defined.
...	@@ -676,27 +488,6 @@ typedef __char32_t char32_t;	...	@@ -676,27 +488,6 @@ typedef __char32_t char32_t;
676	# endif	488	# endif
677	# endif	489	# endif
678		490
679	// It is not yet possible to use aligned_alloc() on all Apple platforms since
680	// 10.15 was the first version to ship an implementation of aligned_alloc().
681	# if defined(__APPLE__)
682	# if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && \
683	__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) \|\| \
684	(defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && \
685	__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) \|\| \
686	(defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && \
687	__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000) \|\| \
688	(defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000)
689	# define _LIBCPP_HAS_C11_ALIGNED_ALLOC 0
690	# else
691	# define _LIBCPP_HAS_C11_ALIGNED_ALLOC 1
692	# endif
693	# elif defined(__ANDROID__) && __ANDROID_API__ < 28
694	// Android only provides aligned_alloc when targeting API 28 or higher.
695	# define _LIBCPP_HAS_C11_ALIGNED_ALLOC 0
696	# else
697	# define _LIBCPP_HAS_C11_ALIGNED_ALLOC 1
698	# endif
699
700	# if defined(__APPLE__) \|\| defined(__FreeBSD__)	491	# if defined(__APPLE__) \|\| defined(__FreeBSD__)
701	# define _LIBCPP_WCTYPE_IS_MASK	492	# define _LIBCPP_WCTYPE_IS_MASK
702	# endif	493	# endif
...	@@ -727,6 +518,15 @@ typedef __char32_t char32_t;	...	@@ -727,6 +518,15 @@ typedef __char32_t char32_t;
727	# define _LIBCPP_DEPRECATED_(m)	518	# define _LIBCPP_DEPRECATED_(m)
728	# endif	519	# endif
729		520
		521	// FIXME: using `#warning` causes diagnostics from system headers which include deprecated headers. This can only be
		522	// enabled again once https://github.com/llvm/llvm-project/pull/168041 (or a similar feature) has landed, since that
		523	// allows suppression in system headers.
		524	# if defined(__DEPRECATED) && __DEPRECATED && !defined(_LIBCPP_DISABLE_DEPRECATION_WARNINGS) && 0
		525	# define _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS 1
		526	# else
		527	# define _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS 0
		528	# endif
		529
730	# if !defined(_LIBCPP_CXX03_LANG)	530	# if !defined(_LIBCPP_CXX03_LANG)
731	# define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED	531	# define _LIBCPP_DEPRECATED_IN_CXX11 _LIBCPP_DEPRECATED
732	# else	532	# else
...	@@ -771,17 +571,6 @@ typedef __char32_t char32_t;	...	@@ -771,17 +571,6 @@ typedef __char32_t char32_t;
771	# define _LIBCPP_DEPRECATED_WITH_CHAR8_T	571	# define _LIBCPP_DEPRECATED_WITH_CHAR8_T
772	# endif	572	# endif
773		573
774	// Macros to enter and leave a state where deprecation warnings are suppressed.
775	# if defined(_LIBCPP_COMPILER_CLANG_BASED) \|\| defined(_LIBCPP_COMPILER_GCC)
776	# define _LIBCPP_SUPPRESS_DEPRECATED_PUSH \
777	_Pragma("GCC diagnostic push") _Pragma("GCC diagnostic ignored \"-Wdeprecated\"") \
778	_Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
779	# define _LIBCPP_SUPPRESS_DEPRECATED_POP _Pragma("GCC diagnostic pop")
780	# else
781	# define _LIBCPP_SUPPRESS_DEPRECATED_PUSH
782	# define _LIBCPP_SUPPRESS_DEPRECATED_POP
783	# endif
784
785	# if _LIBCPP_STD_VER <= 11	574	# if _LIBCPP_STD_VER <= 11
786	# define _LIBCPP_EXPLICIT_SINCE_CXX14	575	# define _LIBCPP_EXPLICIT_SINCE_CXX14
787	# else	576	# else
...	@@ -861,18 +650,10 @@ typedef __char32_t char32_t;	...	@@ -861,18 +650,10 @@ typedef __char32_t char32_t;
861	# endif // _LIBCPP_HAS_THREAD_API	650	# endif // _LIBCPP_HAS_THREAD_API
862	# endif // _LIBCPP_HAS_THREADS	651	# endif // _LIBCPP_HAS_THREADS
863		652
864	# if _LIBCPP_HAS_THREAD_API_PTHREAD	653	# if !_LIBCPP_HAS_THREAD_API_PTHREAD
865	# if defined(__ANDROID__) && __ANDROID_API__ >= 30	654	# define _LIBCPP_HAS_COND_CLOCKWAIT 0
866	# define _LIBCPP_HAS_COND_CLOCKWAIT 1	655	# elif (defined(__ANDROID__) && __ANDROID_API__ >= 30) \|\| _LIBCPP_GLIBC_PREREQ(2, 30)
867	# elif defined(_LIBCPP_GLIBC_PREREQ)	656	# define _LIBCPP_HAS_COND_CLOCKWAIT 1
868	# if _LIBCPP_GLIBC_PREREQ(2, 30)
869	# define _LIBCPP_HAS_COND_CLOCKWAIT 1
870	# else
871	# define _LIBCPP_HAS_COND_CLOCKWAIT 0
872	# endif
873	# else
874	# define _LIBCPP_HAS_COND_CLOCKWAIT 0
875	# endif
876	# else	657	# else
877	# define _LIBCPP_HAS_COND_CLOCKWAIT 0	658	# define _LIBCPP_HAS_COND_CLOCKWAIT 0
878	# endif	659	# endif
...	@@ -951,8 +732,8 @@ typedef __char32_t char32_t;	...	@@ -951,8 +732,8 @@ typedef __char32_t char32_t;
951	# endif	732	# endif
952	# endif	733	# endif
953		734
954	# if defined(__FreeBSD__) && defined(__clang__) && __has_attribute(__no_thread_safety_analysis__)	735	# if __has_cpp_attribute(_Clang::__no_thread_safety_analysis__)
955	# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS __attribute__((__no_thread_safety_analysis__))	736	# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS [[_Clang::__no_thread_safety_analysis__]]
956	# else	737	# else
957	# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS	738	# define _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
958	# endif	739	# endif
...	@@ -1038,12 +819,8 @@ typedef __char32_t char32_t;	...	@@ -1038,12 +819,8 @@ typedef __char32_t char32_t;
1038	// the latter depends on internal GNU libc details that are not appropriate	819	// the latter depends on internal GNU libc details that are not appropriate
1039	// to depend on here, so any declarations present when __cpp_char8_t is not	820	// to depend on here, so any declarations present when __cpp_char8_t is not
1040	// defined are ignored.	821	// defined are ignored.
1041	# if defined(_LIBCPP_GLIBC_PREREQ)	822	# if _LIBCPP_GLIBC_PREREQ(2, 36) && defined(__cpp_char8_t)
1042	# if _LIBCPP_GLIBC_PREREQ(2, 36) && defined(__cpp_char8_t)	823	# define _LIBCPP_HAS_C8RTOMB_MBRTOC8 1
1043	# define _LIBCPP_HAS_C8RTOMB_MBRTOC8 1
1044	# else
1045	# define _LIBCPP_HAS_C8RTOMB_MBRTOC8 0
1046	# endif
1047	# else	824	# else
1048	# define _LIBCPP_HAS_C8RTOMB_MBRTOC8 0	825	# define _LIBCPP_HAS_C8RTOMB_MBRTOC8 0
1049	# endif	826	# endif
...	@@ -1067,8 +844,7 @@ typedef __char32_t char32_t;	...	@@ -1067,8 +844,7 @@ typedef __char32_t char32_t;
1067	# define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")	844	# define _LIBCPP_CTAD_SUPPORTED_FOR_TYPE(_ClassName) static_assert(true, "")
1068	# endif	845	# endif
1069		846
1070	// TODO(LLVM 22): Remove the workaround	847	# if defined(__OBJC__) && defined(_LIBCPP_APPLE_CLANG_VER)
1071	# if defined(__OBJC__) && (!defined(_LIBCPP_CLANG_VER) \|\| _LIBCPP_CLANG_VER < 2001)
1072	# define _LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS	848	# define _LIBCPP_WORKAROUND_OBJCXX_COMPILER_INTRINSICS
1073	# endif	849	# endif
1074		850
...	@@ -1153,12 +929,33 @@ typedef __char32_t char32_t;	...	@@ -1153,12 +929,33 @@ typedef __char32_t char32_t;
1153	# define _LIBCPP_DIAGNOSE_WARNING(...)	929	# define _LIBCPP_DIAGNOSE_WARNING(...)
1154	# endif	930	# endif
1155		931
		932	# if __has_attribute(__diagnose_if__) && !defined(_LIBCPP_APPLE_CLANG_VER) && \
		933	(!defined(_LIBCPP_CLANG_VER) \|\| _LIBCPP_CLANG_VER >= 2001)
		934	# define _LIBCPP_DIAGNOSE_IF(...) __attribute__((__diagnose_if__(__VA_ARGS__)))
		935	# else
		936	# define _LIBCPP_DIAGNOSE_IF(...)
		937	# endif
		938
		939	# define _LIBCPP_DIAGNOSE_NULLPTR_IF(condition, condition_description) \
		940	_LIBCPP_DIAGNOSE_IF( \
		941	condition, \
		942	"null passed to callee that requires a non-null argument" condition_description, \
		943	"warning", \
		944	"nonnull")
		945
1156	# if __has_cpp_attribute(_Clang::__lifetimebound__)	946	# if __has_cpp_attribute(_Clang::__lifetimebound__)
1157	# define _LIBCPP_LIFETIMEBOUND [[_Clang::__lifetimebound__]]	947	# define _LIBCPP_LIFETIMEBOUND [[_Clang::__lifetimebound__]]
1158	# else	948	# else
1159	# define _LIBCPP_LIFETIMEBOUND	949	# define _LIBCPP_LIFETIMEBOUND
1160	# endif	950	# endif
1161		951
		952	// This is to work around https://llvm.org/PR156809
		953	# ifndef _LIBCPP_CXX03_LANG
		954	# define _LIBCPP_CTOR_LIFETIMEBOUND _LIBCPP_LIFETIMEBOUND
		955	# else
		956	# define _LIBCPP_CTOR_LIFETIMEBOUND
		957	# endif
		958
1162	# if __has_cpp_attribute(_Clang::__noescape__)	959	# if __has_cpp_attribute(_Clang::__noescape__)
1163	# define _LIBCPP_NOESCAPE [[_Clang::__noescape__]]	960	# define _LIBCPP_NOESCAPE [[_Clang::__noescape__]]
1164	# else	961	# else
...	@@ -1172,12 +969,6 @@ typedef __char32_t char32_t;	...	@@ -1172,12 +969,6 @@ typedef __char32_t char32_t;
1172	# define _LIBCPP_NO_SPECIALIZATIONS	969	# define _LIBCPP_NO_SPECIALIZATIONS
1173	# endif	970	# endif
1174		971
1175	# if __has_cpp_attribute(_Clang::__standalone_debug__)
1176	# define _LIBCPP_STANDALONE_DEBUG [[_Clang::__standalone_debug__]]
1177	# else
1178	# define _LIBCPP_STANDALONE_DEBUG
1179	# endif
1180
1181	# if __has_cpp_attribute(_Clang::__preferred_name__)	972	# if __has_cpp_attribute(_Clang::__preferred_name__)
1182	# define _LIBCPP_PREFERRED_NAME(x) [[_Clang::__preferred_name__(x)]]	973	# define _LIBCPP_PREFERRED_NAME(x) [[_Clang::__preferred_name__(x)]]
1183	# else	974	# else
...	@@ -1257,14 +1048,6 @@ typedef __char32_t char32_t;	...	@@ -1257,14 +1048,6 @@ typedef __char32_t char32_t;
1257	# define _LIBCPP_DIAGNOSE_NULLPTR	1048	# define _LIBCPP_DIAGNOSE_NULLPTR
1258	# endif	1049	# endif
1259		1050
1260	// TODO(LLVM 22): Remove this macro once LLVM19 support ends. __cpp_explicit_this_parameter has been set in LLVM20.
1261	// Clang-18 has support for deducing this, but it does not set the FTM.
1262	# if defined(__cpp_explicit_this_parameter) \|\| (defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 1800)
1263	# define _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER 1
1264	# else
1265	# define _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER 0
1266	# endif
1267
1268	#endif // __cplusplus	1051	#endif // __cplusplus
1269		1052
1270	#endif // _LIBCPP___CONFIG	1053	#endif // _LIBCPP___CONFIG

lib/libcxx/include/__configuration/abi.h+14-24

 @@ -61,19 +61,9 @@
 // According to the Standard, `bitset::operator[] const` returns bool
 #  define _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
-// In LLVM 20, we've changed to take these ABI breaks unconditionally. These flags only exist in case someone is running
-// into the static_asserts we added to catch the ABI break and don't care that it is one.
-// TODO(LLVM 22): Remove these flags
-#  define _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
-#  define _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
-#  define _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
-#  define _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
 // These flags are documented in ABIGuarantees.rst
 #  define _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
-#  define _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+#  define _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
-#  define _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON
-#  define _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
 #  define _LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI
 #  define _LIBCPP_ABI_ENABLE_UNIQUE_PTR_TRIVIAL_ABI
 #  define _LIBCPP_ABI_FIX_CITYHASH_IMPLEMENTATION
 @@ -84,25 +74,16 @@
 #  define _LIBCPP_ABI_NO_FILESYSTEM_INLINE_NAMESPACE
 #  define _LIBCPP_ABI_NO_ITERATOR_BASES
 #  define _LIBCPP_ABI_NO_RANDOM_DEVICE_COMPATIBILITY_LAYOUT
+#  define _LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER
 #  define _LIBCPP_ABI_OPTIMIZED_FUNCTION
 #  define _LIBCPP_ABI_REGEX_CONSTANTS_NONZERO
 #  define _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
 #  define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_ARRAY
 #  define _LIBCPP_ABI_USE_WRAP_ITER_IN_STD_STRING_VIEW
 #  define _LIBCPP_ABI_VARIANT_INDEX_TYPE_OPTIMIZATION
+#  define _LIBCPP_ABI_TRIVIALLY_COPYABLE_BIT_ITERATOR
 #elif _LIBCPP_ABI_VERSION == 1
-#  if !(defined(_LIBCPP_OBJECT_FORMAT_COFF) || defined(_LIBCPP_OBJECT_FORMAT_XCOFF))
-// Enable compiling copies of now inline methods into the dylib to support
-// applications compiled against older libraries. This is unnecessary with
-// COFF dllexport semantics, since dllexport forces a non-inline definition
-// of inline functions to be emitted anyway. Our own non-inline copy would
-// conflict with the dllexport-emitted copy, so we disable it. For XCOFF,
-// the linker will take issue with the symbols in the shared object if the
-// weak inline methods get visibility (such as from -fvisibility-inlines-hidden),
-// so disable it.
-#    define _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS
-#  endif
 // Feature macros for disabling pre ABI v1 features. All of these options
 // are deprecated.
 #  if defined(__FreeBSD__)
 @@ -110,11 +91,20 @@
 #  endif
 #endif
+// TODO(LLVM 22): Remove this check
+#if defined(_LIBCPP_ABI_NO_ITERATOR_BASES) && !defined(_LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER)
+#  ifndef _LIBCPP_ONLY_NO_ITERATOR_BASES
+#    error "You probably want to define _LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER. This has been split out from"   \
+ " _LIBCPP_ABI_NO_ITERATOR_BASES to allow only removing the second iterator member, since they aren't really related." \
+ "If you actually want this ABI configuration, please define _LIBCPP_ONLY_NO_ITERATOR_BASES instead."
+#  endif
+#endif
 // We had some bugs where we use [[no_unique_address]] together with construct_at,
 // which causes UB as the call on construct_at could write to overlapping subobjects
 //
-// https://github.com/llvm/llvm-project/issues/70506
+// https://llvm.org/PR70506
-// https://github.com/llvm/llvm-project/issues/70494
+// https://llvm.org/PR70494
 //
 // To fix the bug we had to change the ABI of some classes to remove [[no_unique_address]] under certain conditions.
 // The macro below is used for all classes whose ABI have changed as part of fixing these bugs.

lib/libcxx/include/__configuration/availability.h+65-118

 @@ -17,62 +17,17 @@
 #  pragma GCC system_header
 #endif
-// Libc++ is shipped by various vendors. In particular, it is used as a system
+// This file defines a framework that can be used by vendors to encode the version of an operating system that various
-// library on macOS, iOS and other Apple platforms. In order for users to be
+// features of libc++ has been shipped in. This is primarily intended to allow safely deploying an executable built with
-// able to compile a binary that is intended to be deployed to an older version
+// a new version of the library on a platform containing an older version of the built library.
-// of a platform, Clang provides availability attributes [1]. These attributes
+// Detailed documentation for this can be found at https://libcxx.llvm.org/VendorDocumentation.html#availability-markup
-// can be placed on declarations and are used to describe the life cycle of a
-// symbol in the library.
-//
-// The main goal is to ensure a compile-time error if a symbol that hasn't been
-// introduced in a previously released library is used in a program that targets
-// that previously released library. Normally, this would be a load-time error
-// when one tries to launch the program against the older library.
-//
-// For example, the filesystem library was introduced in the dylib in LLVM 9.
-// On Apple platforms, this corresponds to macOS 10.15. If a user compiles on
-// a macOS 10.15 host but targets macOS 10.13 with their program, the compiler
-// would normally not complain (because the required declarations are in the
-// headers), but the dynamic loader would fail to find the symbols when actually
-// trying to launch the program on macOS 10.13. To turn this into a compile-time
-// issue instead, declarations are annotated with when they were introduced, and
-// the compiler can produce a diagnostic if the program references something that
-// isn't available on the deployment target.
-//
-// This mechanism is general in nature, and any vendor can add their markup to
-// the library (see below). Whenever a new feature is added that requires support
-// in the shared library, two macros are added below to allow marking the feature
-// as unavailable:
-// 1. A macro named `_LIBCPP_AVAILABILITY_HAS_<feature>` which must be defined
-//    to `_LIBCPP_INTRODUCED_IN_<version>` for the appropriate LLVM version.
-// 2. A macro named `_LIBCPP_AVAILABILITY_<feature>`, which must be defined to
-//    `_LIBCPP_INTRODUCED_IN_<version>_MARKUP` for the appropriate LLVM version.
-//
-// When vendors decide to ship the feature as part of their shared library, they
-// can update the `_LIBCPP_INTRODUCED_IN_<version>` macro (and the markup counterpart)
-// based on the platform version they shipped that version of LLVM in. The library
-// will then use this markup to provide an optimal user experience on these platforms.
-//
-// Furthermore, many features in the standard library have corresponding
-// feature-test macros. The `_LIBCPP_AVAILABILITY_HAS_<feature>` macros
-// are checked by the corresponding feature-test macros generated by
-// generate_feature_test_macro_components.py to ensure that the library
-// doesn't announce a feature as being implemented if it is unavailable on
-// the deployment target.
-//
-// Note that this mechanism is disabled by default in the "upstream" libc++.
-// Availability annotations are only meaningful when shipping libc++ inside
-// a platform (i.e. as a system library), and so vendors that want them should
-// turn those annotations on at CMake configuration time.
-//
-// [1]: https://clang.llvm.org/docs/AttributeReference.html#availability
 // Availability markup is disabled when building the library, or when a non-Clang
 // compiler is used because only Clang supports the necessary attributes.
 //
 // We also allow users to force-disable availability markup via the `_LIBCPP_DISABLE_AVAILABILITY`
 // macro because that is the only way to work around a Clang bug related to availability
-// attributes: https://github.com/llvm/llvm-project/issues/134151.
+// attributes: https://llvm.org/PR134151.
 // Once that bug has been fixed, we should remove the macro.
 #if defined(_LIBCPP_BUILDING_LIBRARY) || defined(_LIBCXXABI_BUILDING_LIBRARY) ||                                       \
     !defined(_LIBCPP_COMPILER_CLANG_BASED) || defined(_LIBCPP_DISABLE_AVAILABILITY)
 @@ -84,6 +39,9 @@
 // in all versions of the library are available.
 #if !_LIBCPP_HAS_VENDOR_AVAILABILITY_ANNOTATIONS
+#  define _LIBCPP_INTRODUCED_IN_LLVM_22 1
+#  define _LIBCPP_INTRODUCED_IN_LLVM_22_ATTRIBUTE /* nothing */
 #  define _LIBCPP_INTRODUCED_IN_LLVM_21 1
 #  define _LIBCPP_INTRODUCED_IN_LLVM_21_ATTRIBUTE /* nothing */
 @@ -108,32 +66,55 @@
 #  define _LIBCPP_INTRODUCED_IN_LLVM_12 1
 #  define _LIBCPP_INTRODUCED_IN_LLVM_12_ATTRIBUTE /* nothing */
-#  define _LIBCPP_INTRODUCED_IN_LLVM_11 1
-#  define _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE /* nothing */
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9 1
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE      /* nothing */
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_PUSH /* nothing */
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_POP  /* nothing */
 #elif defined(__APPLE__)
 // clang-format off
+// LLVM 22
+// TODO: Fill this in
+#  define _LIBCPP_INTRODUCED_IN_LLVM_22 0
+#  define _LIBCPP_INTRODUCED_IN_LLVM_22_ATTRIBUTE __attribute__((unavailable))
 // LLVM 21
 // TODO: Fill this in
 #  define _LIBCPP_INTRODUCED_IN_LLVM_21 0
 #  define _LIBCPP_INTRODUCED_IN_LLVM_21_ATTRIBUTE __attribute__((unavailable))
 // LLVM 20
-// TODO: Fill this in
+//
-#  define _LIBCPP_INTRODUCED_IN_LLVM_20 0
+// Note that versions for most Apple OSes were bumped forward and aligned in that release.
-#  define _LIBCPP_INTRODUCED_IN_LLVM_20_ATTRIBUTE __attribute__((unavailable))
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 260000) ||       \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 260000) ||     \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 260000) ||             \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 260000) ||       \
+      (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 100000)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_20 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_20 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_20_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 26.0)))                                               \
+    __attribute__((availability(ios, strict, introduced = 26.0)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 26.0)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 26.0)))                                             \
+    __attribute__((availability(bridgeos, strict, introduced = 10.0)))
 // LLVM 19
-// TODO: Fill this in
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 150400) ||       \
-#  define _LIBCPP_INTRODUCED_IN_LLVM_19 0
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 180400) ||     \
-#  define _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE __attribute__((unavailable))
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 180400) ||             \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 110400) ||       \
+      (defined(__ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_BRIDGE_OS_VERSION_MIN_REQUIRED__ < 90400)
+#    define _LIBCPP_INTRODUCED_IN_LLVM_19 0
+#  else
+#    define _LIBCPP_INTRODUCED_IN_LLVM_19 1
+#  endif
+#  define _LIBCPP_INTRODUCED_IN_LLVM_19_ATTRIBUTE                                                                 \
+    __attribute__((availability(macos, strict, introduced = 15.4)))                                               \
+    __attribute__((availability(ios, strict, introduced = 18.4)))                                                 \
+    __attribute__((availability(tvos, strict, introduced = 18.4)))                                                \
+    __attribute__((availability(watchos, strict, introduced = 11.4)))                                             \
+    __attribute__((availability(bridgeos, strict, introduced = 9.4)))
 // LLVM 18
 #  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 150000) ||       \
 @@ -215,47 +196,13 @@
     __attribute__((availability(bridgeos, strict, introduced = 6.0)))                                             \
     __attribute__((availability(driverkit, strict, introduced = 21.3)))
-// LLVM 11
+#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__)  && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__  < 110000) || \
-#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 110000) ||   \
+      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 150000) || \
-      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 140000) || \
+      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__)     && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__     < 150000) || \
-      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 140000) ||         \
+      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__)  && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__  < 80000)  || \
-      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 70000)
+      (defined(__ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_DRIVERKIT_VERSION_MIN_REQUIRED__ < 200000)
-#    define _LIBCPP_INTRODUCED_IN_LLVM_11 0
+#  warning "The selected platform is no longer supported by libc++."
-#  else
-#    define _LIBCPP_INTRODUCED_IN_LLVM_11 1
 #  endif
-#  define _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE                                                                 \
-    __attribute__((availability(macos, strict, introduced = 11.0)))                                               \
-    __attribute__((availability(ios, strict, introduced = 14.0)))                                                 \
-    __attribute__((availability(tvos, strict, introduced = 14.0)))                                                \
-    __attribute__((availability(watchos, strict, introduced = 7.0)))
-// LLVM 9
-#  if (defined(__ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_MAC_OS_X_VERSION_MIN_REQUIRED__ < 101500) ||   \
-      (defined(__ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_IPHONE_OS_VERSION_MIN_REQUIRED__ < 130000) || \
-      (defined(__ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_TV_OS_VERSION_MIN_REQUIRED__ < 130000) ||         \
-      (defined(__ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__) && __ENVIRONMENT_WATCH_OS_VERSION_MIN_REQUIRED__ < 60000)
-#    define _LIBCPP_INTRODUCED_IN_LLVM_9 0
-#  else
-#    define _LIBCPP_INTRODUCED_IN_LLVM_9 1
-#  endif
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE                                                                  \
-    __attribute__((availability(macos, strict, introduced = 10.15)))                                              \
-    __attribute__((availability(ios, strict, introduced = 13.0)))                                                 \
-    __attribute__((availability(tvos, strict, introduced = 13.0)))                                                \
-    __attribute__((availability(watchos, strict, introduced = 6.0)))
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_PUSH                                                                            \
-    _Pragma("clang attribute push(__attribute__((availability(macos,strict,introduced=10.15))), apply_to=any(function,record))") \
-    _Pragma("clang attribute push(__attribute__((availability(ios,strict,introduced=13.0))), apply_to=any(function,record))")    \
-    _Pragma("clang attribute push(__attribute__((availability(tvos,strict,introduced=13.0))), apply_to=any(function,record))")   \
-    _Pragma("clang attribute push(__attribute__((availability(watchos,strict,introduced=6.0))), apply_to=any(function,record))")
-#  define _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_POP                                                                    \
-    _Pragma("clang attribute pop") \
-    _Pragma("clang attribute pop") \
-    _Pragma("clang attribute pop") \
-    _Pragma("clang attribute pop")
-// clang-format on
 #else
 @@ -266,19 +213,12 @@
 #endif
-// These macros control the availability of all parts of <filesystem> that
+// This controls the availability of new implementation of std::atomic's
-// depend on something in the dylib.
+// wait, notify_one and notify_all. The new implementation uses
-#define _LIBCPP_AVAILABILITY_HAS_FILESYSTEM_LIBRARY _LIBCPP_INTRODUCED_IN_LLVM_9
+// the native atomic wait/notify operations on platforms that support them
-#define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE
+// based on the size of the atomic type, instead of the type itself.
-#define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_PUSH
+#define _LIBCPP_AVAILABILITY_HAS_NEW_SYNC _LIBCPP_INTRODUCED_IN_LLVM_22
-#define _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP _LIBCPP_INTRODUCED_IN_LLVM_9_ATTRIBUTE_POP
+#define _LIBCPP_AVAILABILITY_NEW_SYNC _LIBCPP_INTRODUCED_IN_LLVM_22_ATTRIBUTE
-// This controls the availability of the C++20 synchronization library,
-// which requires shared library support for various operations
-// (see libcxx/src/atomic.cpp). This includes <barier>, <latch>,
-// <semaphore>, and notification functions on std::atomic.
-#define _LIBCPP_AVAILABILITY_HAS_SYNC _LIBCPP_INTRODUCED_IN_LLVM_11
-#define _LIBCPP_AVAILABILITY_SYNC _LIBCPP_INTRODUCED_IN_LLVM_11_ATTRIBUTE
 // Enable additional explicit instantiations of iostreams components. This
 // reduces the number of weak definitions generated in programs that use
 @@ -307,7 +247,7 @@
 // This controls the availability of the C++17 std::pmr library,
 // which is implemented in large part in the built library.
 //
-// TODO: Enable std::pmr markup once https://github.com/llvm/llvm-project/issues/40340 has been fixed
+// TODO: Enable std::pmr markup once https://llvm.org/PR40340 has been fixed
 //       Until then, it is possible for folks to try to use `std::pmr` when back-deploying to targets that don't support
 //       it and it'll be a load-time error, but we don't have a good alternative because the library won't compile if we
 //       use availability annotations until that bug has been fixed.
 @@ -364,4 +304,11 @@
 #  define _LIBCPP_AVAILABILITY_INIT_PRIMARY_EXCEPTION
 #endif
+// Only define a bunch of symbols in the dylib if we need to be compatible with LLVM 7 headers or older
+#  if defined(_LIBCPP_BUILDING_LIBRARY) && _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 8
+#    define _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8
+#  else
+#    define _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 _LIBCPP_HIDE_FROM_ABI
+#  endif
 #endif // _LIBCPP___CONFIGURATION_AVAILABILITY_H

lib/libcxx/include/__configuration/compiler.h+6-6

...	@@ -33,16 +33,16 @@	...	@@ -33,16 +33,16 @@
33	// Warn if a compiler version is used that is not supported anymore	33	// Warn if a compiler version is used that is not supported anymore
34	// LLVM RELEASE Update the minimum compiler versions	34	// LLVM RELEASE Update the minimum compiler versions
35	# if defined(_LIBCPP_CLANG_VER)	35	# if defined(_LIBCPP_CLANG_VER)
36	# if _LIBCPP_CLANG_VER < 1900	36	# if _LIBCPP_CLANG_VER < 2001
37	# warning "Libc++ only supports Clang 19 and later"	37	# warning "Libc++ only supports Clang 20 and later"
38	# endif	38	# endif
39	# elif defined(_LIBCPP_APPLE_CLANG_VER)	39	# elif defined(_LIBCPP_APPLE_CLANG_VER)
40	# if _LIBCPP_APPLE_CLANG_VER < 1500	40	# if _LIBCPP_APPLE_CLANG_VER < 1700
41	# warning "Libc++ only supports AppleClang 15 and later"	41	# warning "Libc++ only supports AppleClang 26 and later"
42	# endif	42	# endif
43	# elif defined(_LIBCPP_GCC_VER)	43	# elif defined(_LIBCPP_GCC_VER)
44	# if _LIBCPP_GCC_VER < 1400	44	# if _LIBCPP_GCC_VER < 1500
45	# warning "Libc++ only supports GCC 14 and later"	45	# warning "Libc++ only supports GCC 15 and later"
46	# endif	46	# endif
47	# endif	47	# endif
48		48

lib/libcxx/include/__configuration/experimental.h created+38

...	@@ -0,0 +1,38 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___CONFIGURATION_EXPERIMENTAL_H
10	#define _LIBCPP___CONFIGURATION_EXPERIMENTAL_H
11
12	/* zig patch: instead of including __config_site, zig adds -D flags when compiling */
13
14	#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
15	# pragma GCC system_header
16	#endif
17
18	#if __has_feature(experimental_library)
19	# ifndef _LIBCPP_ENABLE_EXPERIMENTAL
20	# define _LIBCPP_ENABLE_EXPERIMENTAL
21	# endif
22	#endif
23
24	// Incomplete features get their own specific disabling flags. This makes it
25	// easier to grep for target specific flags once the feature is complete.
26	#if defined(_LIBCPP_ENABLE_EXPERIMENTAL) \|\| defined(_LIBCPP_BUILDING_LIBRARY)
27	# define _LIBCPP_HAS_EXPERIMENTAL_LIBRARY 1
28	#else
29	# define _LIBCPP_HAS_EXPERIMENTAL_LIBRARY 0
30	#endif
31
32	#define _LIBCPP_HAS_EXPERIMENTAL_PSTL _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
33	#define _LIBCPP_HAS_EXPERIMENTAL_TZDB _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
34	#define _LIBCPP_HAS_EXPERIMENTAL_SYNCSTREAM _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
35	#define _LIBCPP_HAS_EXPERIMENTAL_HARDENING_OBSERVE_SEMANTIC _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
36	#define _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR _LIBCPP_HAS_EXPERIMENTAL_LIBRARY
37
38	#endif // _LIBCPP___CONFIGURATION_EXPERIMENTAL_H

lib/libcxx/include/__configuration/hardening.h created+215

...	@@ -0,0 +1,215 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___CONFIGURATION_HARDENING_H
10	#define _LIBCPP___CONFIGURATION_HARDENING_H
11
12	/* zig patch: instead of including __config_site, zig adds -D flags when compiling */
13	#include <__configuration/experimental.h>
14	#include <__configuration/language.h>
15
16	#ifndef _LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER
17	# pragma GCC system_header
18	#endif
19
20	// TODO(LLVM 23): Remove this. We're making these an error to catch folks who might not have migrated.
21	// Since hardening went through several changes (many of which impacted user-facing macros),
22	// we're keeping these checks around for a bit longer than usual. Failure to properly configure
23	// hardening results in checks being dropped silently, which is a pretty big deal.
24	#if defined(_LIBCPP_ENABLE_ASSERTIONS)
25	# error "_LIBCPP_ENABLE_ASSERTIONS has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
26	#endif
27	#if defined(_LIBCPP_ENABLE_HARDENED_MODE)
28	# error "_LIBCPP_ENABLE_HARDENED_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
29	#endif
30	#if defined(_LIBCPP_ENABLE_SAFE_MODE)
31	# error "_LIBCPP_ENABLE_SAFE_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
32	#endif
33	#if defined(_LIBCPP_ENABLE_DEBUG_MODE)
34	# error "_LIBCPP_ENABLE_DEBUG_MODE has been removed, please use _LIBCPP_HARDENING_MODE=<mode> instead (see docs)"
35	#endif
36
37	// The library provides the macro `_LIBCPP_HARDENING_MODE` which can be set to one of the following values:
38	//
39	// - `_LIBCPP_HARDENING_MODE_NONE`;
40	// - `_LIBCPP_HARDENING_MODE_FAST`;
41	// - `_LIBCPP_HARDENING_MODE_EXTENSIVE`;
42	// - `_LIBCPP_HARDENING_MODE_DEBUG`.
43	//
44	// These values have the following effects:
45	//
46	// - `_LIBCPP_HARDENING_MODE_NONE` -- sets the hardening mode to "none" which disables all runtime hardening checks;
47	//
48	// - `_LIBCPP_HARDENING_MODE_FAST` -- sets that hardening mode to "fast". The fast mode enables security-critical checks
49	// that can be done with relatively little runtime overhead in constant time;
50	//
51	// - `_LIBCPP_HARDENING_MODE_EXTENSIVE` -- sets the hardening mode to "extensive". The extensive mode is a superset of
52	// the fast mode that additionally enables checks that are relatively cheap and prevent common types of logic errors
53	// but are not necessarily security-critical;
54	//
55	// - `_LIBCPP_HARDENING_MODE_DEBUG` -- sets the hardening mode to "debug". The debug mode is a superset of the extensive
56	// mode and enables all checks available in the library, including internal assertions. Checks that are part of the
57	// debug mode can be very expensive and thus the debug mode is intended to be used for testing, not in production.
58
59	// Inside the library, assertions are categorized so they can be cherry-picked based on the chosen hardening mode. These
60	// macros are only for internal use -- users should only pick one of the high-level hardening modes described above.
61	//
62	// - `_LIBCPP_ASSERT_VALID_INPUT_RANGE` -- checks that ranges (whether expressed as an iterator pair, an iterator and
63	// a sentinel, an iterator and a count, or a `std::range`) given as input to library functions are valid:
64	// - the sentinel is reachable from the begin iterator;
65	// - TODO(hardening): both iterators refer to the same container.
66	//
67	// - `_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS` -- checks that any attempts to access a container element, whether through
68	// the container object or through an iterator, are valid and do not attempt to go out of bounds or otherwise access
69	// a non-existent element. For iterator checks to work, bounded iterators must be enabled in the ABI. Types like
70	// `optional` and `function` are considered one-element containers for the purposes of this check.
71	//
72	// - `_LIBCPP_ASSERT_NON_NULL` -- checks that the pointer being dereferenced is not null. On most modern platforms zero
73	// address does not refer to an actual location in memory, so a null pointer dereference would not compromize the
74	// memory security of a program (however, it is still undefined behavior that can result in strange errors due to
75	// compiler optimizations).
76	//
77	// - `_LIBCPP_ASSERT_NON_OVERLAPPING_RANGES` -- for functions that take several ranges as arguments, checks that the
78	// given ranges do not overlap.
79	//
80	// - `_LIBCPP_ASSERT_VALID_DEALLOCATION` -- checks that an attempt to deallocate memory is valid (e.g. the given object
81	// was allocated by the given allocator). Violating this category typically results in a memory leak.
82	//
83	// - `_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL` -- checks that a call to an external API doesn't fail in
84	// an unexpected manner. This includes triggering documented cases of undefined behavior in an external library (like
85	// attempting to unlock an unlocked mutex in pthreads). Any API external to the library falls under this category
86	// (from system calls to compiler intrinsics). We generally don't expect these failures to compromize memory safety or
87	// otherwise create an immediate security issue.
88	//
89	// - `_LIBCPP_ASSERT_COMPATIBLE_ALLOCATOR` -- checks any operations that exchange nodes between containers to make sure
90	// the containers have compatible allocators.
91	//
92	// - `_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN` -- checks that the given argument is within the domain of valid arguments
93	// for the function. Violating this typically produces an incorrect result (e.g. the clamp algorithm returns the
94	// original value without clamping it due to incorrect functors) or puts an object into an invalid state (e.g.
95	// a string view where only a subset of elements is possible to access). This category is for assertions violating
96	// which doesn't cause any immediate issues in the library -- whatever the consequences are, they will happen in the
97	// user code.
98	//
99	// - `_LIBCPP_ASSERT_PEDANTIC` -- checks prerequisites which are imposed by the Standard, but violating which happens to
100	// be benign in our implementation.
101	//
102	// - `_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT` -- checks that the given argument satisfies the semantic requirements imposed
103	// by the Standard. Typically, there is no simple way to completely prove that a semantic requirement is satisfied;
104	// thus, this would often be a heuristic check and it might be quite expensive.
105	//
106	// - `_LIBCPP_ASSERT_INTERNAL` -- checks that internal invariants of the library hold. These assertions don't depend on
107	// user input.
108	//
109	// - `_LIBCPP_ASSERT_UNCATEGORIZED` -- for assertions that haven't been properly classified yet.
110
111	// clang-format off
112	# define _LIBCPP_HARDENING_MODE_NONE (1 << 1)
113	# define _LIBCPP_HARDENING_MODE_FAST (1 << 2)
114	# define _LIBCPP_HARDENING_MODE_EXTENSIVE (1 << 4) // Deliberately not ordered.
115	# define _LIBCPP_HARDENING_MODE_DEBUG (1 << 3)
116	// clang-format on
117
118	#ifndef _LIBCPP_HARDENING_MODE
119
120	# ifndef _LIBCPP_HARDENING_MODE_DEFAULT
121	# error _LIBCPP_HARDENING_MODE_DEFAULT is not defined. This definition should be set at configuration time in the \
122	`__config_site` header, please make sure your installation of libc++ is not broken.
123	# endif
124
125	# define _LIBCPP_HARDENING_MODE _LIBCPP_HARDENING_MODE_DEFAULT
126	#endif
127
128	#if _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_NONE && _LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_FAST && \
129	_LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_EXTENSIVE && \
130	_LIBCPP_HARDENING_MODE != _LIBCPP_HARDENING_MODE_DEBUG
131	# error _LIBCPP_HARDENING_MODE must be set to one of the following values: \
132	_LIBCPP_HARDENING_MODE_NONE, \
133	_LIBCPP_HARDENING_MODE_FAST, \
134	_LIBCPP_HARDENING_MODE_EXTENSIVE, \
135	_LIBCPP_HARDENING_MODE_DEBUG
136	#endif
137
138	// The library provides the macro `_LIBCPP_ASSERTION_SEMANTIC` for configuring the assertion semantic used by hardening;
139	// it can be set to one of the following values:
140	//
141	// - `_LIBCPP_ASSERTION_SEMANTIC_IGNORE`;
142	// - `_LIBCPP_ASSERTION_SEMANTIC_OBSERVE`;
143	// - `_LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE`;
144	// - `_LIBCPP_ASSERTION_SEMANTIC_ENFORCE`.
145	//
146	// libc++ assertion semantics generally mirror the evaluation semantics of C++26 Contracts:
147	// - `ignore` evaluates the assertion but doesn't do anything if it fails (note that it differs from the Contracts
148	// `ignore` semantic which wouldn't evaluate the assertion at all);
149	// - `observe` logs an error (indicating, if possible, that the error is fatal) and continues execution;
150	// - `quick-enforce` terminates the program as fast as possible (via trapping);
151	// - `enforce` logs an error and then terminates the program.
152	//
153	// Additionally, a special `hardening-dependent` value selects the assertion semantic based on the hardening mode in
154	// effect: the production-capable modes (`fast` and `extensive`) map to `quick_enforce` and the `debug` mode maps to
155	// `enforce`. The `hardening-dependent` semantic cannot be selected explicitly, it is only used when no assertion
156	// semantic is provided by the user _and_ the library's default semantic is configured to be dependent on hardening.
157	//
158	// Notes:
159	// - Continuing execution after a hardening check fails results in undefined behavior; the `observe` semantic is meant
160	// to make adopting hardening easier but should not be used outside of this scenario;
161	// - C++26 wording for Library Hardening precludes a conforming Hardened implementation from using the Contracts
162	// `ignore` semantic when evaluating hardened preconditions in the Library. Libc++ allows using this semantic for
163	// hardened preconditions, however, be aware that using `ignore` does not produce a conforming "Hardened"
164	// implementation, unlike the other semantics above.
165	// clang-format off
166	# define _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT (1 << 1)
167	# define _LIBCPP_ASSERTION_SEMANTIC_IGNORE (1 << 2)
168	# define _LIBCPP_ASSERTION_SEMANTIC_OBSERVE (1 << 3)
169	# define _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE (1 << 4)
170	# define _LIBCPP_ASSERTION_SEMANTIC_ENFORCE (1 << 5)
171	// clang-format on
172
173	// If the user attempts to configure the assertion semantic, check that it is allowed in the current environment.
174	#if defined(_LIBCPP_ASSERTION_SEMANTIC)
175	# if !_LIBCPP_HAS_EXPERIMENTAL_LIBRARY
176	# error "Assertion semantics are an experimental feature."
177	# endif
178	# if defined(_LIBCPP_CXX03_LANG)
179	# error "Assertion semantics are not available in the C++03 mode."
180	# endif
181	#endif // defined(_LIBCPP_ASSERTION_SEMANTIC)
182
183	// User-provided semantic takes top priority -- don't override if set.
184	#ifndef _LIBCPP_ASSERTION_SEMANTIC
185
186	# ifndef _LIBCPP_ASSERTION_SEMANTIC_DEFAULT
187	# error _LIBCPP_ASSERTION_SEMANTIC_DEFAULT is not defined. This definition should be set at configuration time in \
188	the `__config_site` header, please make sure your installation of libc++ is not broken.
189	# endif
190
191	# if _LIBCPP_ASSERTION_SEMANTIC_DEFAULT != _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT
192	# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_DEFAULT
193	# else
194	# if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
195	# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_ENFORCE
196	# else
197	# define _LIBCPP_ASSERTION_SEMANTIC _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE
198	# endif
199	# endif // _LIBCPP_ASSERTION_SEMANTIC_DEFAULT != _LIBCPP_ASSERTION_SEMANTIC_HARDENING_DEPENDENT
200
201	#endif // #ifndef _LIBCPP_ASSERTION_SEMANTIC
202
203	// Finally, validate the selected semantic (in case the user tries setting it to an incorrect value):
204	#if _LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_IGNORE && \
205	_LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_OBSERVE && \
206	_LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE && \
207	_LIBCPP_ASSERTION_SEMANTIC != _LIBCPP_ASSERTION_SEMANTIC_ENFORCE
208	# error _LIBCPP_ASSERTION_SEMANTIC must be set to one of the following values: \
209	_LIBCPP_ASSERTION_SEMANTIC_IGNORE, \
210	_LIBCPP_ASSERTION_SEMANTIC_OBSERVE, \
211	_LIBCPP_ASSERTION_SEMANTIC_QUICK_ENFORCE, \
212	_LIBCPP_ASSERTION_SEMANTIC_ENFORCE
213	#endif
214
215	#endif // _LIBCPP___CONFIGURATION_HARDENING_H

lib/libcxx/include/__configuration/language.h+3

 @@ -18,6 +18,9 @@
 // NOLINTBEGIN(libcpp-cpp-version-check)
 #ifdef __cplusplus
+#  if __cplusplus < 201103L
+#    define _LIBCPP_CXX03_LANG
+#  endif
 #  if __cplusplus <= 201103L
 #    define _LIBCPP_STD_VER 11
 #  elif __cplusplus <= 201402L

lib/libcxx/include/__configuration/platform.h+9-16

...	@@ -31,22 +31,15 @@	...	@@ -31,22 +31,15 @@
31	#endif	31	#endif
32		32
33	// Need to detect which libc we're using if we're on Linux.	33	// Need to detect which libc we're using if we're on Linux.
34	#if defined(__linux__) \|\| defined(__AMDGPU__) \|\| defined(__NVPTX__)	34	#if (defined(__linux__) \|\| defined(__AMDGPU__) \|\| defined(__NVPTX__)) && __has_include(<features.h>)
35	# if __has_include(<features.h>)	35	# include <features.h>
36	# include <features.h>	36	# if defined(__GLIBC_PREREQ)
37	# if defined(__GLIBC_PREREQ)	37	# define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)
38	# define _LIBCPP_GLIBC_PREREQ(a, b) __GLIBC_PREREQ(a, b)	38	# else
39	# else	39	# define _LIBCPP_GLIBC_PREREQ(a, b) 0
40	# define _LIBCPP_GLIBC_PREREQ(a, b) 0	40	# endif // defined(__GLIBC_PREREQ)
41	# endif // defined(__GLIBC_PREREQ)	41	#else
42	# endif	42	# define _LIBCPP_GLIBC_PREREQ(a, b) 0
43	#endif
44
45	// This is required in order for _NEWLIB_VERSION to be defined in places where we use it.
46	// TODO: We shouldn't be including arbitrarily-named headers from libc++ since this can break valid
47	// user code. Move code paths that need _NEWLIB_VERSION to another customization mechanism.
48	#if __has_include(<picolibc.h>)
49	# include <picolibc.h>
50	#endif	43	#endif
51		44
52	#ifndef __BYTE_ORDER__	45	#ifndef __BYTE_ORDER__

lib/libcxx/include/__coroutine/coroutine_handle.h+9-9

...	@@ -44,9 +44,9 @@ public:	...	@@ -44,9 +44,9 @@ public:
44	}	44	}
45		45
46	// [coroutine.handle.export.import], export/import	46	// [coroutine.handle.export.import], export/import
47	_LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }	47	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }
48		48
49	_LIBCPP_HIDE_FROM_ABI static constexpr coroutine_handle from_address(void* __addr) noexcept {	49	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr coroutine_handle from_address(void* __addr) noexcept {
50	coroutine_handle __tmp;	50	coroutine_handle __tmp;
51	__tmp.__handle_ = __addr;	51	__tmp.__handle_ = __addr;
52	return __tmp;	52	return __tmp;
...	@@ -55,7 +55,7 @@ public:	...	@@ -55,7 +55,7 @@ public:
55	// [coroutine.handle.observers], observers	55	// [coroutine.handle.observers], observers
56	_LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __handle_ != nullptr; }	56	_LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __handle_ != nullptr; }
57		57
58	_LIBCPP_HIDE_FROM_ABI bool done() const {	58	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool done() const {
59	_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "done() can be called only on suspended coroutines");	59	_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "done() can be called only on suspended coroutines");
60	return __builtin_coro_done(__handle_);	60	return __builtin_coro_done(__handle_);
61	}	61	}
...	@@ -100,7 +100,7 @@ public:	...	@@ -100,7 +100,7 @@ public:
100		100
101	_LIBCPP_HIDE_FROM_ABI constexpr coroutine_handle(nullptr_t) noexcept {}	101	_LIBCPP_HIDE_FROM_ABI constexpr coroutine_handle(nullptr_t) noexcept {}
102		102
103	_LIBCPP_HIDE_FROM_ABI static coroutine_handle from_promise(_Promise& __promise) {	103	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static coroutine_handle from_promise(_Promise& __promise) {
104	using _RawPromise = __remove_cv_t<_Promise>;	104	using _RawPromise = __remove_cv_t<_Promise>;
105	coroutine_handle __tmp;	105	coroutine_handle __tmp;
106	__tmp.__handle_ =	106	__tmp.__handle_ =
...	@@ -114,9 +114,9 @@ public:	...	@@ -114,9 +114,9 @@ public:
114	}	114	}
115		115
116	// [coroutine.handle.export.import], export/import	116	// [coroutine.handle.export.import], export/import
117	_LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }	117	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }
118		118
119	_LIBCPP_HIDE_FROM_ABI static constexpr coroutine_handle from_address(void* __addr) noexcept {	119	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr coroutine_handle from_address(void* __addr) noexcept {
120	coroutine_handle __tmp;	120	coroutine_handle __tmp;
121	__tmp.__handle_ = __addr;	121	__tmp.__handle_ = __addr;
122	return __tmp;	122	return __tmp;
...	@@ -130,7 +130,7 @@ public:	...	@@ -130,7 +130,7 @@ public:
130	// [coroutine.handle.observers], observers	130	// [coroutine.handle.observers], observers
131	_LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __handle_ != nullptr; }	131	_LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return __handle_ != nullptr; }
132		132
133	_LIBCPP_HIDE_FROM_ABI bool done() const {	133	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool done() const {
134	_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "done() can be called only on suspended coroutines");	134	_LIBCPP_ASSERT_VALID_EXTERNAL_API_CALL(__is_suspended(), "done() can be called only on suspended coroutines");
135	return __builtin_coro_done(__handle_);	135	return __builtin_coro_done(__handle_);
136	}	136	}
...	@@ -150,7 +150,7 @@ public:	...	@@ -150,7 +150,7 @@ public:
150	}	150	}
151		151
152	// [coroutine.handle.promise], promise access	152	// [coroutine.handle.promise], promise access
153	_LIBCPP_HIDE_FROM_ABI _Promise& promise() const {	153	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Promise& promise() const {
154	return static_cast<_Promise>(__builtin_coro_promise(this->__handle_, alignof(_Promise), false));	154	return static_cast<_Promise>(__builtin_coro_promise(this->__handle_, alignof(_Promise), false));
155	}	155	}
156		156
...	@@ -165,7 +165,7 @@ private:	...	@@ -165,7 +165,7 @@ private:
165	// [coroutine.handle.hash]	165	// [coroutine.handle.hash]
166	template <class _Tp>	166	template <class _Tp>
167	struct hash<coroutine_handle<_Tp>> {	167	struct hash<coroutine_handle<_Tp>> {
168	_LIBCPP_HIDE_FROM_ABI size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept {	168	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const coroutine_handle<_Tp>& __v) const noexcept {
169	return hash<void*>()(__v.address());	169	return hash<void*>()(__v.address());
170	}	170	}
171	};	171	};

lib/libcxx/include/__coroutine/noop_coroutine_handle.h+11-13

lib/libcxx/include/__debug_utils/strict_weak_ordering_check.h+1-1

...	@@ -27,7 +27,7 @@ template <class _RandomAccessIterator, class _Comp>	...	@@ -27,7 +27,7 @@ template <class _RandomAccessIterator, class _Comp>
27	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void	27	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
28	__check_strict_weak_ordering_sorted(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) {	28	__check_strict_weak_ordering_sorted(_RandomAccessIterator __first, _RandomAccessIterator __last, _Comp& __comp) {
29	#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG	29	#if _LIBCPP_HARDENING_MODE == _LIBCPP_HARDENING_MODE_DEBUG
30	using __diff_t = __iter_diff_t<_RandomAccessIterator>;	30	using __diff_t = __iterator_difference_type<_RandomAccessIterator>;
31	using _Comp_ref = __comp_ref_type<_Comp>;	31	using _Comp_ref = __comp_ref_type<_Comp>;
32	if (!__libcpp_is_constant_evaluated()) {	32	if (!__libcpp_is_constant_evaluated()) {
33	// Check if the range is actually sorted.	33	// Check if the range is actually sorted.

lib/libcxx/include/__exception/exception.h+6-4

 @@ -48,13 +48,15 @@ public:
     __data_._DoFree = true;
   }
-  exception(exception const&) _NOEXCEPT {}
+  exception(exception const&) _NOEXCEPT : __data_() {}
   exception& operator=(exception const&) _NOEXCEPT { return *this; }
   virtual ~exception() _NOEXCEPT {}
-  virtual char const* what() const _NOEXCEPT { return __data_._What ? __data_._What : "Unknown exception"; }
+  [[__nodiscard__]] virtual char const* what() const _NOEXCEPT {
+    return __data_._What ? __data_._What : "Unknown exception";
+  }
 private:
   __std_exception_data __data_;
 @@ -76,7 +78,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI exception& operator=(const exception&) _NOEXCEPT = default;
   virtual ~exception() _NOEXCEPT;
-  virtual const char* what() const _NOEXCEPT;
+  [[__nodiscard__]] virtual const char* what() const _NOEXCEPT;
 };
 class _LIBCPP_EXPORTED_FROM_ABI bad_exception : public exception {
 @@ -85,7 +87,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bad_exception(const bad_exception&) _NOEXCEPT            = default;
   _LIBCPP_HIDE_FROM_ABI bad_exception& operator=(const bad_exception&) _NOEXCEPT = default;
   ~bad_exception() _NOEXCEPT override;
-  const char* what() const _NOEXCEPT override;
+  [[__nodiscard__]] const char* what() const _NOEXCEPT override;
 };
 #endif // !_LIBCPP_ABI_VCRUNTIME

lib/libcxx/include/__exception/exception_ptr.h+27-5

 @@ -11,18 +11,24 @@
 #include <__config>
 #include <__cstddef/nullptr_t.h>
+#include <__cstddef/size_t.h>
 #include <__exception/operations.h>
 #include <__memory/addressof.h>
 #include <__memory/construct_at.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/is_pointer.h>
-#include <cstdlib>
+#include <__utility/move.h>
+#include <__utility/swap.h>
+#include <__verbose_abort>
 #include <typeinfo>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 #ifndef _LIBCPP_ABI_MICROSOFT
 #  if _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION
 @@ -30,7 +36,7 @@
 namespace __cxxabiv1 {
 extern "C" {
-_LIBCPP_OVERRIDABLE_FUNC_VIS void* __cxa_allocate_exception(size_t) throw();
+_LIBCPP_OVERRIDABLE_FUNC_VIS void* __cxa_allocate_exception(std::size_t) throw();
 _LIBCPP_OVERRIDABLE_FUNC_VIS void __cxa_free_exception(void*) throw();
 struct __cxa_exception;
 @@ -57,6 +63,8 @@ _LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD
 #ifndef _LIBCPP_ABI_MICROSOFT
+inline _LIBCPP_HIDE_FROM_ABI void swap(exception_ptr& __x, exception_ptr& __y) _NOEXCEPT;
 class _LIBCPP_EXPORTED_FROM_ABI exception_ptr {
   void* __ptr_;
 @@ -67,15 +75,21 @@ class _LIBCPP_EXPORTED_FROM_ABI exception_ptr {
 public:
   // exception_ptr is basically a COW string so it is trivially relocatable.
-  // It is also replaceable because assignment has normal value semantics.
   using __trivially_relocatable _LIBCPP_NODEBUG = exception_ptr;
-  using __replaceable _LIBCPP_NODEBUG           = exception_ptr;
   _LIBCPP_HIDE_FROM_ABI exception_ptr() _NOEXCEPT : __ptr_() {}
   _LIBCPP_HIDE_FROM_ABI exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
   exception_ptr(const exception_ptr&) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI exception_ptr(exception_ptr&& __other) _NOEXCEPT : __ptr_(__other.__ptr_) {
+    __other.__ptr_ = nullptr;
+  }
   exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI exception_ptr& operator=(exception_ptr&& __other) _NOEXCEPT {
+    exception_ptr __tmp(std::move(__other));
+    std::swap(__tmp, *this);
+    return *this;
+  }
   ~exception_ptr() _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __ptr_ != nullptr; }
 @@ -88,10 +102,16 @@ public:
     return !(__x == __y);
   }
+  friend _LIBCPP_HIDE_FROM_ABI void swap(exception_ptr& __x, exception_ptr& __y) _NOEXCEPT;
   friend _LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;
   friend _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);
 };
+inline _LIBCPP_HIDE_FROM_ABI void swap(exception_ptr& __x, exception_ptr& __y) _NOEXCEPT {
+  std::swap(__x.__ptr_, __y.__ptr_);
+}
 #  if _LIBCPP_HAS_EXCEPTIONS
 #    if _LIBCPP_AVAILABILITY_HAS_INIT_PRIMARY_EXCEPTION
 template <class _Ep>
 @@ -153,7 +173,7 @@ _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT {
 #  else  // !_LIBCPP_HAS_EXCEPTIONS
 template <class _Ep>
 _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep) _NOEXCEPT {
-  std::abort();
+  _LIBCPP_VERBOSE_ABORT("make_exception_ptr was called in -fno-exceptions mode");
 }
 #  endif // _LIBCPP_HAS_EXCEPTIONS
 @@ -201,4 +221,6 @@ _LIBCPP_HIDE_FROM_ABI exception_ptr make_exception_ptr(_Ep __e) _NOEXCEPT {
 #endif // _LIBCPP_ABI_MICROSOFT
 _LIBCPP_END_UNVERSIONED_NAMESPACE_STD
+_LIBCPP_POP_MACROS
 #endif // _LIBCPP___EXCEPTION_EXCEPTION_PTR_H

lib/libcxx/include/__exception/nested_exception.h+2-2

...	@@ -40,7 +40,7 @@ public:	...	@@ -40,7 +40,7 @@ public:
40		40
41	// access functions	41	// access functions
42	[[__noreturn__]] void rethrow_nested() const;	42	[[__noreturn__]] void rethrow_nested() const;
43	_LIBCPP_HIDE_FROM_ABI exception_ptr nested_ptr() const _NOEXCEPT { return __ptr_; }	43	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI exception_ptr nested_ptr() const _NOEXCEPT { return __ptr_; }
44	};	44	};
45		45
46	template <class _Tp>	46	template <class _Tp>
...	@@ -73,7 +73,7 @@ template <class _Tp>	...	@@ -73,7 +73,7 @@ template <class _Tp>
73	__throw_with_nested<_Tp,	73	__throw_with_nested<_Tp,
74	_Up,	74	_Up,
75	is_class<_Up>::value && !is_base_of<nested_exception, _Up>::value &&	75	is_class<_Up>::value && !is_base_of<nested_exception, _Up>::value &&
76	!__libcpp_is_final<_Up>::value>::__do_throw(std::forward<_Tp>(__t));	76	!__is_final_v<_Up> >::__do_throw(std::forward<_Tp>(__t));
77	#else	77	#else
78	((void)__t);	78	((void)__t);
79	// FIXME: Make this abort	79	// FIXME: Make this abort

lib/libcxx/include/__exception/operations.h+5-5

lib/libcxx/include/__expected/bad_expected_access.h+8-6

 @@ -43,9 +43,11 @@ protected:
 public:
 #  if _LIBCPP_AVAILABILITY_HAS_BAD_EXPECTED_ACCESS_KEY_FUNCTION
-  const char* what() const noexcept override;
+  [[nodiscard]] const char* what() const noexcept override;
 #  else
-  _LIBCPP_HIDE_FROM_ABI_VIRTUAL const char* what() const noexcept override { return "bad access to std::expected"; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI_VIRTUAL const char* what() const noexcept override {
+    return "bad access to std::expected";
+  }
 #  endif
 };
 _LIBCPP_DIAGNOSTIC_POP
 @@ -55,10 +57,10 @@ class bad_expected_access : public bad_expected_access<void> {
 public:
   _LIBCPP_HIDE_FROM_ABI explicit bad_expected_access(_Err __e) : __unex_(std::move(__e)) {}
-  _LIBCPP_HIDE_FROM_ABI _Err& error() & noexcept { return __unex_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Err& error() & noexcept { return __unex_; }
-  _LIBCPP_HIDE_FROM_ABI const _Err& error() const& noexcept { return __unex_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const _Err& error() const& noexcept { return __unex_; }
-  _LIBCPP_HIDE_FROM_ABI _Err&& error() && noexcept { return std::move(__unex_); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Err&& error() && noexcept { return std::move(__unex_); }
-  _LIBCPP_HIDE_FROM_ABI const _Err&& error() const&& noexcept { return std::move(__unex_); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const _Err&& error() const&& noexcept { return std::move(__unex_); }
 private:
   _Err __unex_;

lib/libcxx/include/__expected/expected.h+62-64

lib/libcxx/include/__expected/unexpected.h+4-4

...	@@ -89,10 +89,10 @@ public:	...	@@ -89,10 +89,10 @@ public:
89	_LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(const unexpected&) = default;	89	_LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(const unexpected&) = default;
90	_LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(unexpected&&) = default;	90	_LIBCPP_HIDE_FROM_ABI constexpr unexpected& operator=(unexpected&&) = default;
91		91
92	_LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { return __unex_; }	92	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err& error() const& noexcept { return __unex_; }
93	_LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { return __unex_; }	93	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err& error() & noexcept { return __unex_; }
94	_LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { return std::move(__unex_); }	94	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Err&& error() const&& noexcept { return std::move(__unex_); }
95	_LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { return std::move(__unex_); }	95	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Err&& error() && noexcept { return std::move(__unex_); }
96		96
97	_LIBCPP_HIDE_FROM_ABI constexpr void swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Err>) {	97	_LIBCPP_HIDE_FROM_ABI constexpr void swap(unexpected& __other) noexcept(is_nothrow_swappable_v<_Err>) {
98	static_assert(is_swappable_v<_Err>, "unexpected::swap requires is_swappable_v<E> to be true");	98	static_assert(is_swappable_v<_Err>, "unexpected::swap requires is_swappable_v<E> to be true");

lib/libcxx/include/__filesystem/copy_options.h+4-4

...	@@ -34,19 +34,19 @@ enum class copy_options : unsigned short {	...	@@ -34,19 +34,19 @@ enum class copy_options : unsigned short {
34	__in_recursive_copy = 512,	34	__in_recursive_copy = 512,
35	};	35	};
36		36
37	_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator&(copy_options __lhs, copy_options __rhs) {	37	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator&(copy_options __lhs, copy_options __rhs) {
38	return static_cast<copy_options>(static_cast<unsigned short>(__lhs) & static_cast<unsigned short>(__rhs));	38	return static_cast<copy_options>(static_cast<unsigned short>(__lhs) & static_cast<unsigned short>(__rhs));
39	}	39	}
40		40
41	_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator\|(copy_options __lhs, copy_options __rhs) {	41	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator\|(copy_options __lhs, copy_options __rhs) {
42	return static_cast<copy_options>(static_cast<unsigned short>(__lhs) \| static_cast<unsigned short>(__rhs));	42	return static_cast<copy_options>(static_cast<unsigned short>(__lhs) \| static_cast<unsigned short>(__rhs));
43	}	43	}
44		44
45	_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator^(copy_options __lhs, copy_options __rhs) {	45	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator^(copy_options __lhs, copy_options __rhs) {
46	return static_cast<copy_options>(static_cast<unsigned short>(__lhs) ^ static_cast<unsigned short>(__rhs));	46	return static_cast<copy_options>(static_cast<unsigned short>(__lhs) ^ static_cast<unsigned short>(__rhs));
47	}	47	}
48		48
49	_LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator~(copy_options __lhs) {	49	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr copy_options operator~(copy_options __lhs) {
50	return static_cast<copy_options>(~static_cast<unsigned short>(__lhs));	50	return static_cast<copy_options>(~static_cast<unsigned short>(__lhs));
51	}	51	}
52		52

lib/libcxx/include/__filesystem/directory_entry.h+37-33

lib/libcxx/include/__filesystem/directory_iterator.h+9-11

...	@@ -34,8 +34,6 @@ _LIBCPP_PUSH_MACROS	...	@@ -34,8 +34,6 @@ _LIBCPP_PUSH_MACROS
34		34
35	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM	35	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
36		36
37	_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
38
39	class _LIBCPP_HIDDEN __dir_stream;	37	class _LIBCPP_HIDDEN __dir_stream;
40	class directory_iterator {	38	class directory_iterator {
41	public:	39	public:
...	@@ -73,7 +71,7 @@ public:	...	@@ -73,7 +71,7 @@ public:
73		71
74	_LIBCPP_HIDE_FROM_ABI ~directory_iterator() = default;	72	_LIBCPP_HIDE_FROM_ABI ~directory_iterator() = default;
75		73
76	_LIBCPP_HIDE_FROM_ABI const directory_entry& operator*() const {	74	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI const directory_entry& operator*() const {
77	// Note: this check duplicates a check in `__dereference()`.	75	// Note: this check duplicates a check in `__dereference()`.
78	_LIBCPP_ASSERT_NON_NULL(__imp_, "The end iterator cannot be dereferenced");	76	_LIBCPP_ASSERT_NON_NULL(__imp_, "The end iterator cannot be dereferenced");
79	return __dereference();	77	return __dereference();
...	@@ -123,23 +121,23 @@ operator!=(const directory_iterator& __lhs, const directory_iterator& __rhs) noe	...	@@ -123,23 +121,23 @@ operator!=(const directory_iterator& __lhs, const directory_iterator& __rhs) noe
123	}	121	}
124		122
125	// enable directory_iterator range-based for statements	123	// enable directory_iterator range-based for statements
126	inline _LIBCPP_HIDE_FROM_ABI directory_iterator begin(directory_iterator __iter) noexcept { return __iter; }	124	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI directory_iterator begin(directory_iterator __iter) noexcept {
127		125	return __iter;
128	inline _LIBCPP_HIDE_FROM_ABI directory_iterator end(directory_iterator) noexcept { return directory_iterator(); }	126	}
129		127
130	_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP	128	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI directory_iterator end(directory_iterator) noexcept {
		129	return directory_iterator();
		130	}
131		131
132	_LIBCPP_END_NAMESPACE_FILESYSTEM	132	_LIBCPP_END_NAMESPACE_FILESYSTEM
133		133
134	# if _LIBCPP_STD_VER >= 20	134	# if _LIBCPP_STD_VER >= 20
135		135
136	template <>	136	template <>
137	_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool	137	inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;
138	std::ranges::enable_borrowed_range<std::filesystem::directory_iterator> = true;
139		138
140	template <>	139	template <>
141	_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool	140	inline constexpr bool std::ranges::enable_view<std::filesystem::directory_iterator> = true;
142	std::ranges::enable_view<std::filesystem::directory_iterator> = true;
143		141
144	# endif // _LIBCPP_STD_VER >= 20	142	# endif // _LIBCPP_STD_VER >= 20
145		143

lib/libcxx/include/__filesystem/directory_options.h+7-4

 @@ -22,19 +22,22 @@ _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
 enum class directory_options : unsigned char { none = 0, follow_directory_symlink = 1, skip_permission_denied = 2 };
-_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator&(directory_options __lhs, directory_options __rhs) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr directory_options
+operator&(directory_options __lhs, directory_options __rhs) {
   return static_cast<directory_options>(static_cast<unsigned char>(__lhs) & static_cast<unsigned char>(__rhs));
 }
-_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator|(directory_options __lhs, directory_options __rhs) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr directory_options
+operator|(directory_options __lhs, directory_options __rhs) {
   return static_cast<directory_options>(static_cast<unsigned char>(__lhs) | static_cast<unsigned char>(__rhs));
 }
-_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator^(directory_options __lhs, directory_options __rhs) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr directory_options
+operator^(directory_options __lhs, directory_options __rhs) {
   return static_cast<directory_options>(static_cast<unsigned char>(__lhs) ^ static_cast<unsigned char>(__rhs));
 }
-_LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator~(directory_options __lhs) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr directory_options operator~(directory_options __lhs) {
   return static_cast<directory_options>(~static_cast<unsigned char>(__lhs));
 }

lib/libcxx/include/__filesystem/file_status.h+3-3

...	@@ -22,7 +22,7 @@	...	@@ -22,7 +22,7 @@
22		22
23	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM	23	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
24		24
25	class _LIBCPP_EXPORTED_FROM_ABI file_status {	25	class file_status {
26	public:	26	public:
27	// constructors	27	// constructors
28	_LIBCPP_HIDE_FROM_ABI file_status() noexcept : file_status(file_type::none) {}	28	_LIBCPP_HIDE_FROM_ABI file_status() noexcept : file_status(file_type::none) {}
...	@@ -38,9 +38,9 @@ public:	...	@@ -38,9 +38,9 @@ public:
38	_LIBCPP_HIDE_FROM_ABI file_status& operator=(file_status&&) noexcept = default;	38	_LIBCPP_HIDE_FROM_ABI file_status& operator=(file_status&&) noexcept = default;
39		39
40	// observers	40	// observers
41	_LIBCPP_HIDE_FROM_ABI file_type type() const noexcept { return __ft_; }	41	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_type type() const noexcept { return __ft_; }
42		42
43	_LIBCPP_HIDE_FROM_ABI perms permissions() const noexcept { return __prms_; }	43	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI perms permissions() const noexcept { return __prms_; }
44		44
45	// modifiers	45	// modifiers
46	_LIBCPP_HIDE_FROM_ABI void type(file_type __ft) noexcept { __ft_ = __ft; }	46	_LIBCPP_HIDE_FROM_ABI void type(file_type __ft) noexcept { __ft_ = __ft; }

lib/libcxx/include/__filesystem/filesystem_error.h+9-10

 @@ -27,7 +27,7 @@
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-class _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_EXPORTED_FROM_ABI filesystem_error : public system_error {
+class _LIBCPP_EXPORTED_FROM_ABI filesystem_error : public system_error {
 public:
   _LIBCPP_HIDE_FROM_ABI filesystem_error(const string& __what, error_code __ec)
       : system_error(__ec, __what), __storage_(make_shared<_Storage>(path(), path())) {
 @@ -44,15 +44,16 @@ public:
     __create_what(2);
   }
-  _LIBCPP_HIDE_FROM_ABI const path& path1() const noexcept { return __storage_->__p1_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const path& path1() const noexcept { return __storage_->__p1_; }
-  _LIBCPP_HIDE_FROM_ABI const path& path2() const noexcept { return __storage_->__p2_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const path& path2() const noexcept { return __storage_->__p2_; }
-  _LIBCPP_HIDE_FROM_ABI filesystem_error(const filesystem_error&) = default;
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI filesystem_error(const filesystem_error&) = default;
   ~filesystem_error() override; // key function
-  _LIBCPP_HIDE_FROM_ABI_VIRTUAL
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI_VIRTUAL const char* what() const noexcept override {
-  const char* what() const noexcept override { return __storage_->__what_.c_str(); }
+    return __storage_->__what_.c_str();
+  }
   void __create_what(int __num_paths);
 @@ -69,14 +70,12 @@ private:
 #  if _LIBCPP_HAS_EXCEPTIONS
 template <class... _Args>
-[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY void
+[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_filesystem_error(_Args&&... __args) {
-__throw_filesystem_error(_Args&&... __args) {
   throw filesystem_error(std::forward<_Args>(__args)...);
 }
 #  else
 template <class... _Args>
-[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY void
+[[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_filesystem_error(_Args&&...) {
-__throw_filesystem_error(_Args&&...) {
   _LIBCPP_VERBOSE_ABORT("filesystem_error was thrown in -fno-exceptions mode");
 }
 #  endif

lib/libcxx/include/__filesystem/operations.h+97-66

 @@ -31,8 +31,6 @@
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 _LIBCPP_EXPORTED_FROM_ABI path __absolute(const path&, error_code* __ec = nullptr);
 _LIBCPP_EXPORTED_FROM_ABI path __canonical(const path&, error_code* __ec = nullptr);
 _LIBCPP_EXPORTED_FROM_ABI bool
 @@ -70,10 +68,14 @@ _LIBCPP_EXPORTED_FROM_ABI bool __fs_is_empty(const path& __p, error_code* __ec =
 _LIBCPP_EXPORTED_FROM_ABI void __permissions(const path&, perms, perm_options, error_code* = nullptr);
 _LIBCPP_EXPORTED_FROM_ABI space_info __space(const path&, error_code* __ec = nullptr);
-inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p) { return __absolute(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p) { return __absolute(__p); }
-inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p, error_code& __ec) { return __absolute(__p, &__ec); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path absolute(const path& __p, error_code& __ec) {
-inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p) { return __canonical(__p); }
+  return __absolute(__p, &__ec);
-inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p, error_code& __ec) { return __canonical(__p, &__ec); }
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p) { return __canonical(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path canonical(const path& __p, error_code& __ec) {
+  return __canonical(__p, &__ec);
+}
 inline _LIBCPP_HIDE_FROM_ABI bool copy_file(const path& __from, const path& __to) {
   return __copy_file(__from, __to, copy_options::none);
 }
 @@ -137,85 +139,112 @@ inline _LIBCPP_HIDE_FROM_ABI void create_symlink(const path& __target, const pat
 inline _LIBCPP_HIDE_FROM_ABI void create_symlink(const path& __target, const path& __link, error_code& __ec) noexcept {
   return __create_symlink(__target, __link, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI path current_path() { return __current_path(); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path current_path() { return __current_path(); }
-inline _LIBCPP_HIDE_FROM_ABI path current_path(error_code& __ec) { return __current_path(&__ec); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path current_path(error_code& __ec) { return __current_path(&__ec); }
 inline _LIBCPP_HIDE_FROM_ABI void current_path(const path& __p) { __current_path(__p); }
 inline _LIBCPP_HIDE_FROM_ABI void current_path(const path& __p, error_code& __ec) noexcept {
   __current_path(__p, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI bool equivalent(const path& __p1, const path& __p2) { return __equivalent(__p1, __p2); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool equivalent(const path& __p1, const path& __p2) {
-inline _LIBCPP_HIDE_FROM_ABI bool equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
+  return __equivalent(__p1, __p2);
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool
+equivalent(const path& __p1, const path& __p2, error_code& __ec) noexcept {
   return __equivalent(__p1, __p2, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI bool status_known(file_status __s) noexcept { return __s.type() != file_type::none; }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool status_known(file_status __s) noexcept {
-inline _LIBCPP_HIDE_FROM_ABI bool exists(file_status __s) noexcept {
+  return __s.type() != file_type::none;
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool exists(file_status __s) noexcept {
   return status_known(__s) && __s.type() != file_type::not_found;
 }
-inline _LIBCPP_HIDE_FROM_ABI bool exists(const path& __p) { return exists(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool exists(const path& __p) { return exists(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool exists(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool exists(const path& __p, error_code& __ec) noexcept {
   auto __s = __status(__p, &__ec);
   if (status_known(__s))
     __ec.clear();
   return exists(__s);
 }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p) { return __file_size(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p) { return __file_size(__p); }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(const path& __p, error_code& __ec) noexcept {
   return __file_size(__p, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p) { return __hard_link_count(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p) { return __hard_link_count(__p); }
-inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(const path& __p, error_code& __ec) noexcept {
   return __hard_link_count(__p, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(file_status __s) noexcept { return __s.type() == file_type::block; }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(file_status __s) noexcept {
-inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p) { return is_block_file(__status(__p)); }
+  return __s.type() == file_type::block;
-inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p, error_code& __ec) noexcept {
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p) { return is_block_file(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_block_file(const path& __p, error_code& __ec) noexcept {
   return is_block_file(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(file_status __s) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(file_status __s) noexcept {
   return __s.type() == file_type::character;
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p) { return is_character_file(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p) {
-inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p, error_code& __ec) noexcept {
+  return is_character_file(__status(__p));
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_character_file(const path& __p, error_code& __ec) noexcept {
   return is_character_file(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_directory(file_status __s) noexcept { return __s.type() == file_type::directory; }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_directory(file_status __s) noexcept {
-inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p) { return is_directory(__status(__p)); }
+  return __s.type() == file_type::directory;
-inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p, error_code& __ec) noexcept {
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p) { return is_directory(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_directory(const path& __p, error_code& __ec) noexcept {
   return is_directory(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p) { return __fs_is_empty(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p) { return __fs_is_empty(__p); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p, error_code& __ec) { return __fs_is_empty(__p, &__ec); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_empty(const path& __p, error_code& __ec) {
-inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(file_status __s) noexcept { return __s.type() == file_type::fifo; }
+  return __fs_is_empty(__p, &__ec);
-inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p) { return is_fifo(__status(__p)); }
+}
-inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(file_status __s) noexcept {
+  return __s.type() == file_type::fifo;
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p) { return is_fifo(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_fifo(const path& __p, error_code& __ec) noexcept {
   return is_fifo(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(file_status __s) noexcept { return __s.type() == file_type::regular; }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(file_status __s) noexcept {
-inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p) { return is_regular_file(__status(__p)); }
+  return __s.type() == file_type::regular;
-inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p, error_code& __ec) noexcept {
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p) {
+  return is_regular_file(__status(__p));
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_regular_file(const path& __p, error_code& __ec) noexcept {
   return is_regular_file(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(file_status __s) noexcept { return __s.type() == file_type::symlink; }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(file_status __s) noexcept {
-inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p) { return is_symlink(__symlink_status(__p)); }
+  return __s.type() == file_type::symlink;
-inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p, error_code& __ec) noexcept {
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p) {
+  return is_symlink(__symlink_status(__p));
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_symlink(const path& __p, error_code& __ec) noexcept {
   return is_symlink(__symlink_status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_other(file_status __s) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_other(file_status __s) noexcept {
   return exists(__s) && !is_regular_file(__s) && !is_directory(__s) && !is_symlink(__s);
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p) { return is_other(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p) { return is_other(__status(__p)); }
-inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_other(const path& __p, error_code& __ec) noexcept {
   return is_other(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI bool is_socket(file_status __s) noexcept { return __s.type() == file_type::socket; }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_socket(file_status __s) noexcept {
-inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p) { return is_socket(__status(__p)); }
+  return __s.type() == file_type::socket;
-inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p, error_code& __ec) noexcept {
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p) { return is_socket(__status(__p)); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool is_socket(const path& __p, error_code& __ec) noexcept {
   return is_socket(__status(__p, &__ec));
 }
-inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p) { return __last_write_time(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p) {
-inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p, error_code& __ec) noexcept {
+  return __last_write_time(__p);
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(const path& __p, error_code& __ec) noexcept {
   return __last_write_time(__p, &__ec);
 }
 inline _LIBCPP_HIDE_FROM_ABI void last_write_time(const path& __p, file_time_type __t) { __last_write_time(__p, __t); }
 @@ -233,7 +262,7 @@ inline _LIBCPP_HIDE_FROM_ABI void permissions(const path& __p, perms __prms, per
   __permissions(__p, __prms, __opts, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base, error_code& __ec) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base, error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return {};
 @@ -243,16 +272,18 @@ inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base,
   return __tmp.lexically_proximate(__tmp_base);
 }
-inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, error_code& __ec) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, error_code& __ec) {
   return proximate(__p, current_path(), __ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base = current_path()) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path proximate(const path& __p, const path& __base = current_path()) {
   return __weakly_canonical(__p).lexically_proximate(__weakly_canonical(__base));
 }
-inline _LIBCPP_HIDE_FROM_ABI path read_symlink(const path& __p) { return __read_symlink(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path read_symlink(const path& __p) { return __read_symlink(__p); }
-inline _LIBCPP_HIDE_FROM_ABI path read_symlink(const path& __p, error_code& __ec) { return __read_symlink(__p, &__ec); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path read_symlink(const path& __p, error_code& __ec) {
+  return __read_symlink(__p, &__ec);
+}
-inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base, error_code& __ec) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base, error_code& __ec) {
   path __tmp = __weakly_canonical(__p, &__ec);
   if (__ec)
     return path();
 @@ -262,10 +293,10 @@ inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base,
   return __tmp.lexically_relative(__tmpbase);
 }
-inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, error_code& __ec) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, error_code& __ec) {
   return relative(__p, current_path(), __ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base = current_path()) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path relative(const path& __p, const path& __base = current_path()) {
   return __weakly_canonical(__p).lexically_relative(__weakly_canonical(__base));
 }
 inline _LIBCPP_HIDE_FROM_ABI uintmax_t remove_all(const path& __p) { return __remove_all(__p); }
 @@ -282,27 +313,27 @@ inline _LIBCPP_HIDE_FROM_ABI void resize_file(const path& __p, uintmax_t __ns) {
 inline _LIBCPP_HIDE_FROM_ABI void resize_file(const path& __p, uintmax_t __ns, error_code& __ec) noexcept {
   return __resize_file(__p, __ns, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p) { return __space(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p) { return __space(__p); }
-inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI space_info space(const path& __p, error_code& __ec) noexcept {
   return __space(__p, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p) { return __status(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p) { return __status(__p); }
-inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI file_status status(const path& __p, error_code& __ec) noexcept {
   return __status(__p, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p) { return __symlink_status(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p) { return __symlink_status(__p); }
-inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p, error_code& __ec) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI file_status symlink_status(const path& __p, error_code& __ec) noexcept {
   return __symlink_status(__p, &__ec);
 }
-inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path() { return __temp_directory_path(); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path() { return __temp_directory_path(); }
-inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path(error_code& __ec) { return __temp_directory_path(&__ec); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path temp_directory_path(error_code& __ec) {
-inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p) { return __weakly_canonical(__p); }
+  return __temp_directory_path(&__ec);
-inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p, error_code& __ec) {
+}
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p) { return __weakly_canonical(__p); }
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI path weakly_canonical(path const& __p, error_code& __ec) {
   return __weakly_canonical(__p, &__ec);
 }
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 #endif // _LIBCPP_STD_VER >= 17 && _LIBCPP_HAS_FILESYSTEM

lib/libcxx/include/__filesystem/path.h+68-64

 @@ -42,8 +42,6 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 template <class _Tp>
 struct __can_convert_char {
   static const bool value = false;
 @@ -326,6 +324,7 @@ struct _PathCVT<char> {
   }
 };
+#    if _LIBCPP_HAS_LOCALIZATION
 template <class _ECharT>
 struct _PathExport {
   typedef __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Narrower;
 @@ -366,7 +365,7 @@ struct _PathExport<char16_t> {
   }
 };
-#    if _LIBCPP_HAS_CHAR8_T
+#      if _LIBCPP_HAS_CHAR8_T
 template <>
 struct _PathExport<char8_t> {
   typedef __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__> _Narrower;
 @@ -376,8 +375,9 @@ struct _PathExport<char8_t> {
     _Narrower()(back_inserter(__dest), __src.data(), __src.data() + __src.size());
   }
 };
-#    endif // _LIBCPP_HAS_CHAR8_T
+#      endif // _LIBCPP_HAS_CHAR8_T
-#  endif   /* _LIBCPP_WIN32API */
+#    endif   // _LIBCPP_HAS_LOCALIZATION
+#  endif     // _LIBCPP_WIN32API
 class _LIBCPP_EXPORTED_FROM_ABI path {
   template <class _SourceOrIter, class _Tp = path&>
 @@ -667,16 +667,16 @@ public:
   _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __s) { __pn_.reserve(__s); }
   // native format observers
-  _LIBCPP_HIDE_FROM_ABI const string_type& native() const noexcept { return __pn_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const string_type& native() const noexcept { return __pn_; }
-  _LIBCPP_HIDE_FROM_ABI const value_type* c_str() const noexcept { return __pn_.c_str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const value_type* c_str() const noexcept { return __pn_.c_str(); }
   _LIBCPP_HIDE_FROM_ABI operator string_type() const { return __pn_; }
 #  if defined(_LIBCPP_WIN32API)
-  _LIBCPP_HIDE_FROM_ABI std::wstring wstring() const { return __pn_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::wstring wstring() const { return __pn_; }
-  _LIBCPP_HIDE_FROM_ABI std::wstring generic_wstring() const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::wstring generic_wstring() const {
     std::wstring __s;
     __s.resize(__pn_.size());
     std::replace_copy(__pn_.begin(), __pn_.end(), __s.begin(), '\\', '/');
 @@ -685,6 +685,7 @@ public:
 #    if _LIBCPP_HAS_LOCALIZATION
   template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
+  [[nodiscard]]
   _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator> string(const _Allocator& __a = _Allocator()) const {
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s(__a);
 @@ -693,8 +694,8 @@ public:
     return __s;
   }
-  _LIBCPP_HIDE_FROM_ABI std::string string() const { return string<char>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::string string() const { return string<char>(); }
-  _LIBCPP_HIDE_FROM_ABI __u8_string u8string() const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI __u8_string u8string() const {
     using _CVT = __narrow_to_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
     __u8_string __s;
     __s.reserve(__pn_.size());
 @@ -702,12 +703,12 @@ public:
     return __s;
   }
-  _LIBCPP_HIDE_FROM_ABI std::u16string u16string() const { return string<char16_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u16string u16string() const { return string<char16_t>(); }
-  _LIBCPP_HIDE_FROM_ABI std::u32string u32string() const { return string<char32_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u32string u32string() const { return string<char32_t>(); }
   // generic format observers
   template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
-  _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
     _Str __s   = string<_ECharT, _Traits, _Allocator>(__a);
 @@ -718,10 +719,10 @@ public:
     return __s;
   }
-  _LIBCPP_HIDE_FROM_ABI std::string generic_string() const { return generic_string<char>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::string generic_string() const { return generic_string<char>(); }
-  _LIBCPP_HIDE_FROM_ABI std::u16string generic_u16string() const { return generic_string<char16_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u16string generic_u16string() const { return generic_string<char16_t>(); }
-  _LIBCPP_HIDE_FROM_ABI std::u32string generic_u32string() const { return generic_string<char32_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u32string generic_u32string() const { return generic_string<char32_t>(); }
-  _LIBCPP_HIDE_FROM_ABI __u8_string generic_u8string() const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI __u8_string generic_u8string() const {
     __u8_string __s = u8string();
     std::replace(__s.begin(), __s.end(), '\\', '/');
     return __s;
 @@ -729,15 +730,18 @@ public:
 #    endif // _LIBCPP_HAS_LOCALIZATION
 #  else    /* _LIBCPP_WIN32API */
-  _LIBCPP_HIDE_FROM_ABI std::string string() const { return __pn_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::string string() const { return __pn_; }
 #    if _LIBCPP_HAS_CHAR8_T
-  _LIBCPP_HIDE_FROM_ABI std::u8string u8string() const { return std::u8string(__pn_.begin(), __pn_.end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u8string u8string() const {
+    return std::u8string(__pn_.begin(), __pn_.end());
+  }
 #    else
-  _LIBCPP_HIDE_FROM_ABI std::string u8string() const { return __pn_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::string u8string() const { return __pn_; }
 #    endif
 #    if _LIBCPP_HAS_LOCALIZATION
   template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
+  [[nodiscard]]
   _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator> string(const _Allocator& __a = _Allocator()) const {
     using _CVT = __widen_from_utf8<sizeof(_ECharT) * __CHAR_BIT__>;
     using _Str = basic_string<_ECharT, _Traits, _Allocator>;
 @@ -748,32 +752,34 @@ public:
   }
 #      if _LIBCPP_HAS_WIDE_CHARACTERS
-  _LIBCPP_HIDE_FROM_ABI std::wstring wstring() const { return string<wchar_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::wstring wstring() const { return string<wchar_t>(); }
 #      endif
-  _LIBCPP_HIDE_FROM_ABI std::u16string u16string() const { return string<char16_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u16string u16string() const { return string<char16_t>(); }
-  _LIBCPP_HIDE_FROM_ABI std::u32string u32string() const { return string<char32_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u32string u32string() const { return string<char32_t>(); }
 #    endif // _LIBCPP_HAS_LOCALIZATION
   // generic format observers
-  _LIBCPP_HIDE_FROM_ABI std::string generic_string() const { return __pn_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::string generic_string() const { return __pn_; }
 #    if _LIBCPP_HAS_CHAR8_T
-  _LIBCPP_HIDE_FROM_ABI std::u8string generic_u8string() const { return std::u8string(__pn_.begin(), __pn_.end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u8string generic_u8string() const {
+    return std::u8string(__pn_.begin(), __pn_.end());
+  }
 #    else
-  _LIBCPP_HIDE_FROM_ABI std::string generic_u8string() const { return __pn_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::string generic_u8string() const { return __pn_; }
 #    endif
 #    if _LIBCPP_HAS_LOCALIZATION
   template <class _ECharT, class _Traits = char_traits<_ECharT>, class _Allocator = allocator<_ECharT> >
-  _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string<_ECharT, _Traits, _Allocator>
   generic_string(const _Allocator& __a = _Allocator()) const {
     return string<_ECharT, _Traits, _Allocator>(__a);
   }
 #      if _LIBCPP_HAS_WIDE_CHARACTERS
-  _LIBCPP_HIDE_FROM_ABI std::wstring generic_wstring() const { return string<wchar_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::wstring generic_wstring() const { return string<wchar_t>(); }
 #      endif
-  _LIBCPP_HIDE_FROM_ABI std::u16string generic_u16string() const { return string<char16_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u16string generic_u16string() const { return string<char16_t>(); }
-  _LIBCPP_HIDE_FROM_ABI std::u32string generic_u32string() const { return string<char32_t>(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::u32string generic_u32string() const { return string<char32_t>(); }
 #    endif // _LIBCPP_HAS_LOCALIZATION
 #  endif   /* !_LIBCPP_WIN32API */
 @@ -790,40 +796,40 @@ private:
 public:
   // compare
-  _LIBCPP_HIDE_FROM_ABI int compare(const path& __p) const noexcept { return __compare(__p.__pn_); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI int compare(const path& __p) const noexcept { return __compare(__p.__pn_); }
-  _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return __compare(__s); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return __compare(__s); }
-  _LIBCPP_HIDE_FROM_ABI int compare(__string_view __s) const { return __compare(__s); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI int compare(__string_view __s) const { return __compare(__s); }
-  _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return __compare(__s); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return __compare(__s); }
   // decomposition
-  _LIBCPP_HIDE_FROM_ABI path root_name() const { return string_type(__root_name()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path root_name() const { return string_type(__root_name()); }
-  _LIBCPP_HIDE_FROM_ABI path root_directory() const { return string_type(__root_directory()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path root_directory() const { return string_type(__root_directory()); }
-  _LIBCPP_HIDE_FROM_ABI path root_path() const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path root_path() const {
 #  if defined(_LIBCPP_WIN32API)
     return string_type(__root_path_raw());
 #  else
     return root_name().append(string_type(__root_directory()));
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI path relative_path() const { return string_type(__relative_path()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path relative_path() const { return string_type(__relative_path()); }
-  _LIBCPP_HIDE_FROM_ABI path parent_path() const { return string_type(__parent_path()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path parent_path() const { return string_type(__parent_path()); }
-  _LIBCPP_HIDE_FROM_ABI path filename() const { return string_type(__filename()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path filename() const { return string_type(__filename()); }
-  _LIBCPP_HIDE_FROM_ABI path stem() const { return string_type(__stem()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path stem() const { return string_type(__stem()); }
-  _LIBCPP_HIDE_FROM_ABI path extension() const { return string_type(__extension()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path extension() const { return string_type(__extension()); }
   // query
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __pn_.empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_root_name() const { return !__root_name().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_root_name() const { return !__root_name().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_root_directory() const { return !__root_directory().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_root_directory() const { return !__root_directory().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_root_path() const { return !__root_path_raw().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_root_path() const { return !__root_path_raw().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_relative_path() const { return !__relative_path().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_relative_path() const { return !__relative_path().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_parent_path() const { return !__parent_path().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_parent_path() const { return !__parent_path().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_filename() const { return !__filename().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_filename() const { return !__filename().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_stem() const { return !__stem().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_stem() const { return !__stem().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool has_extension() const { return !__extension().empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_extension() const { return !__extension().empty(); }
-  _LIBCPP_HIDE_FROM_ABI bool is_absolute() const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_absolute() const {
 #  if defined(_LIBCPP_WIN32API)
     __string_view __root_name_str = __root_name();
     __string_view __root_dir      = __root_directory();
 @@ -847,13 +853,13 @@ public:
     return has_root_directory();
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI bool is_relative() const { return !is_absolute(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_relative() const { return !is_absolute(); }
   // relative paths
-  path lexically_normal() const;
+  [[nodiscard]] path lexically_normal() const;
-  path lexically_relative(const path& __base) const;
+  [[nodiscard]] path lexically_relative(const path& __base) const;
-  _LIBCPP_HIDE_FROM_ABI path lexically_proximate(const path& __base) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI path lexically_proximate(const path& __base) const {
     path __result = this->lexically_relative(__base);
     if (__result.native().empty())
       return *this;
 @@ -861,11 +867,11 @@ public:
   }
   // iterators
-  class _LIBCPP_EXPORTED_FROM_ABI iterator;
+  class iterator;
   typedef iterator const_iterator;
-  iterator begin() const;
+  [[nodiscard]] iterator begin() const;
-  iterator end() const;
+  [[nodiscard]] iterator end() const;
 #  if _LIBCPP_HAS_LOCALIZATION
   template <
 @@ -908,17 +914,15 @@ private:
 inline _LIBCPP_HIDE_FROM_ABI void swap(path& __lhs, path& __rhs) noexcept { __lhs.swap(__rhs); }
-_LIBCPP_EXPORTED_FROM_ABI size_t hash_value(const path& __p) noexcept;
+[[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI size_t hash_value(const path& __p) noexcept;
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <>
-struct _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY hash<filesystem::path> : __unary_function<filesystem::path, size_t> {
+struct hash<filesystem::path> : __unary_function<filesystem::path, size_t> {
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(filesystem::path const& __p) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t operator()(filesystem::path const& __p) const noexcept {
     return filesystem::hash_value(__p);
   }
 };

lib/libcxx/include/__filesystem/path_iterator.h+1-3

 @@ -52,7 +52,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI iterator& operator=(const iterator&) = default;
-  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __stashed_elem_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __stashed_elem_; }
   _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return &__stashed_elem_; }
 @@ -95,12 +95,10 @@ private:
   _ParserState __state_;
 };
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const path::iterator& __lhs, const path::iterator& __rhs) {
   return __lhs.__path_ptr_ == __rhs.__path_ptr_ && __lhs.__entry_.data() == __rhs.__entry_.data();
 }
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const path::iterator& __lhs, const path::iterator& __rhs) {
   return !(__lhs == __rhs);
 }

lib/libcxx/include/__filesystem/perm_options.h+4-4

...	@@ -22,19 +22,19 @@ _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM	...	@@ -22,19 +22,19 @@ _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
22		22
23	enum class perm_options : unsigned char { replace = 1, add = 2, remove = 4, nofollow = 8 };	23	enum class perm_options : unsigned char { replace = 1, add = 2, remove = 4, nofollow = 8 };
24		24
25	_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {	25	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator&(perm_options __lhs, perm_options __rhs) {
26	return static_cast<perm_options>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));	26	return static_cast<perm_options>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));
27	}	27	}
28		28
29	_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator\|(perm_options __lhs, perm_options __rhs) {	29	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator\|(perm_options __lhs, perm_options __rhs) {
30	return static_cast<perm_options>(static_cast<unsigned>(__lhs) \| static_cast<unsigned>(__rhs));	30	return static_cast<perm_options>(static_cast<unsigned>(__lhs) \| static_cast<unsigned>(__rhs));
31	}	31	}
32		32
33	_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator^(perm_options __lhs, perm_options __rhs) {	33	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator^(perm_options __lhs, perm_options __rhs) {
34	return static_cast<perm_options>(static_cast<unsigned>(__lhs) ^ static_cast<unsigned>(__rhs));	34	return static_cast<perm_options>(static_cast<unsigned>(__lhs) ^ static_cast<unsigned>(__rhs));
35	}	35	}
36		36
37	_LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator~(perm_options __lhs) {	37	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perm_options operator~(perm_options __lhs) {
38	return static_cast<perm_options>(~static_cast<unsigned>(__lhs));	38	return static_cast<perm_options>(~static_cast<unsigned>(__lhs));
39	}	39	}
40		40

lib/libcxx/include/__filesystem/perms.h+4-4

...	@@ -51,19 +51,19 @@ enum class perms : unsigned {	...	@@ -51,19 +51,19 @@ enum class perms : unsigned {
51	unknown = 0xFFFF,	51	unknown = 0xFFFF,
52	};	52	};
53		53
54	_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator&(perms __lhs, perms __rhs) {	54	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perms operator&(perms __lhs, perms __rhs) {
55	return static_cast<perms>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));	55	return static_cast<perms>(static_cast<unsigned>(__lhs) & static_cast<unsigned>(__rhs));
56	}	56	}
57		57
58	_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator\|(perms __lhs, perms __rhs) {	58	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perms operator\|(perms __lhs, perms __rhs) {
59	return static_cast<perms>(static_cast<unsigned>(__lhs) \| static_cast<unsigned>(__rhs));	59	return static_cast<perms>(static_cast<unsigned>(__lhs) \| static_cast<unsigned>(__rhs));
60	}	60	}
61		61
62	_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator^(perms __lhs, perms __rhs) {	62	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perms operator^(perms __lhs, perms __rhs) {
63	return static_cast<perms>(static_cast<unsigned>(__lhs) ^ static_cast<unsigned>(__rhs));	63	return static_cast<perms>(static_cast<unsigned>(__lhs) ^ static_cast<unsigned>(__rhs));
64	}	64	}
65		65
66	_LIBCPP_HIDE_FROM_ABI inline constexpr perms operator~(perms __lhs) {	66	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI inline constexpr perms operator~(perms __lhs) {
67	return static_cast<perms>(~static_cast<unsigned>(__lhs));	67	return static_cast<perms>(~static_cast<unsigned>(__lhs));
68	}	68	}
69		69

lib/libcxx/include/__filesystem/recursive_directory_iterator.h+9-14

 @@ -33,8 +33,6 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
 class recursive_directory_iterator {
 public:
   using value_type        = directory_entry;
 @@ -73,7 +71,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI ~recursive_directory_iterator() = default;
-  _LIBCPP_HIDE_FROM_ABI const directory_entry& operator*() const { return __dereference(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const directory_entry& operator*() const { return __dereference(); }
   _LIBCPP_HIDE_FROM_ABI const directory_entry* operator->() const { return &__dereference(); }
 @@ -87,14 +85,14 @@ public:
   _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator& increment(error_code& __ec) { return __increment(&__ec); }
-  _LIBCPP_EXPORTED_FROM_ABI directory_options options() const;
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI directory_options options() const;
-  _LIBCPP_EXPORTED_FROM_ABI int depth() const;
+  [[nodiscard]] _LIBCPP_EXPORTED_FROM_ABI int depth() const;
   _LIBCPP_HIDE_FROM_ABI void pop() { __pop(); }
   _LIBCPP_HIDE_FROM_ABI void pop(error_code& __ec) { __pop(&__ec); }
-  _LIBCPP_HIDE_FROM_ABI bool recursion_pending() const { return __rec_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool recursion_pending() const { return __rec_; }
   _LIBCPP_HIDE_FROM_ABI void disable_recursion_pending() { __rec_ = false; }
 @@ -132,27 +130,24 @@ operator!=(const recursive_directory_iterator& __lhs, const recursive_directory_
   return !(__lhs == __rhs);
 }
 // enable recursive_directory_iterator range-based for statements
-inline _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator begin(recursive_directory_iterator __iter) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator
+begin(recursive_directory_iterator __iter) noexcept {
   return __iter;
 }
-inline _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator end(recursive_directory_iterator) noexcept {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI recursive_directory_iterator end(recursive_directory_iterator) noexcept {
   return recursive_directory_iterator();
 }
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 #  if _LIBCPP_STD_VER >= 20
 template <>
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool
+inline constexpr bool std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;
-    std::ranges::enable_borrowed_range<std::filesystem::recursive_directory_iterator> = true;
 template <>
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY inline constexpr bool
+inline constexpr bool std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
-    std::ranges::enable_view<std::filesystem::recursive_directory_iterator> = true;
 #  endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/__filesystem/space_info.h+1-1

...	@@ -21,7 +21,7 @@	...	@@ -21,7 +21,7 @@
21		21
22	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM	22	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
23		23
24	struct _LIBCPP_EXPORTED_FROM_ABI space_info {	24	struct space_info {
25	uintmax_t capacity;	25	uintmax_t capacity;
26	uintmax_t free;	26	uintmax_t free;
27	uintmax_t available;	27	uintmax_t available;

lib/libcxx/include/__filesystem/u8path.h+12-14

 @@ -24,32 +24,32 @@
 _LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
+#  if !defined(_LIBCPP_WIN32API) || _LIBCPP_HAS_LOCALIZATION
 template <class _InputIt, __enable_if_t<__is_pathable<_InputIt>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f, _InputIt __l) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f, _InputIt __l) {
   static_assert(
-#  if _LIBCPP_HAS_CHAR8_T
+#    if _LIBCPP_HAS_CHAR8_T
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
-#  endif
+#    endif
           is_same<typename __is_pathable<_InputIt>::__char_type, char>::value,
       "u8path(Iter, Iter) requires Iter have a value_type of type 'char'"
       " or 'char8_t'");
-#  if defined(_LIBCPP_WIN32API)
+#    if defined(_LIBCPP_WIN32API)
   string __tmp(__f, __l);
   using _CVT = __widen_from_utf8<sizeof(wchar_t) * __CHAR_BIT__>;
   std::wstring __w;
   __w.reserve(__tmp.size());
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
-#  else
+#    else
   return path(__f, __l);
-#  endif /* !_LIBCPP_WIN32API */
+#    endif // defined(_LIBCPP_WIN32API)
 }
+#  endif // !defined(_LIBCPP_WIN32API) || _LIBCPP_HAS_LOCALIZATION
-#  if defined(_LIBCPP_WIN32API)
+#  if defined(_LIBCPP_WIN32API) && _LIBCPP_HAS_LOCALIZATION
 template <class _InputIt, __enable_if_t<__is_pathable<_InputIt>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f, _NullSentinel) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f, _NullSentinel) {
   static_assert(
 #    if _LIBCPP_HAS_CHAR8_T
       is_same<typename __is_pathable<_InputIt>::__char_type, char8_t>::value ||
 @@ -67,10 +67,10 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(_InputIt __f,
   _CVT()(back_inserter(__w), __tmp.data(), __tmp.data() + __tmp.size());
   return path(__w);
 }
-#  endif /* _LIBCPP_WIN32API */
+#  endif // defined(_LIBCPP_WIN32API) && _LIBCPP_HAS_LOCALIZATION
 template <class _Source, __enable_if_t<__is_pathable<_Source>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(const _Source& __s) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(const _Source& __s) {
   static_assert(
 #  if _LIBCPP_HAS_CHAR8_T
       is_same<typename __is_pathable<_Source>::__char_type, char8_t>::value ||
 @@ -86,8 +86,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_DEPRECATED_WITH_CHAR8_T path u8path(const _Source&
 #  endif
 }
-_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
 _LIBCPP_END_NAMESPACE_FILESYSTEM
 #endif // _LIBCPP_STD_VER >= 17

lib/libcxx/include/__flat_map/flat_map.h+88-71

 @@ -29,7 +29,6 @@
 #include <__flat_map/key_value_iterator.h>
 #include <__flat_map/sorted_unique.h>
 #include <__flat_map/utils.h>
-#include <__functional/invoke.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__fwd/memory.h>
 @@ -48,7 +47,7 @@
 #include <__ranges/container_compatible_range.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/from_range.h>
-#include <__ranges/ref_view.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/zip_view.h>
 @@ -410,41 +409,45 @@ public:
   }
   // iterators
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator begin() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator begin() noexcept {
     return iterator(__containers_.keys.begin(), __containers_.values.begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator begin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator begin() const noexcept {
     return const_iterator(__containers_.keys.begin(), __containers_.values.begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator end() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator end() noexcept {
     return iterator(__containers_.keys.end(), __containers_.values.end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator end() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator end() const noexcept {
     return const_iterator(__containers_.keys.end(), __containers_.values.end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rbegin() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rbegin() noexcept {
     return reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rbegin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rbegin() const noexcept {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rend() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rend() noexcept {
     return reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rend() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rend() const noexcept {
     return const_reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cbegin() const noexcept { return begin(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cbegin() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cend() const noexcept { return end(); }
+    return begin();
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crbegin() const noexcept {
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cend() const noexcept {
+    return end();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crbegin() const noexcept {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crend() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crend() const noexcept {
     return const_reverse_iterator(begin());
   }
 @@ -453,11 +456,11 @@ public:
     return __containers_.keys.empty();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type size() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type size() const noexcept {
     return __containers_.keys.size();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type max_size() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type max_size() const noexcept {
     return std::min<size_type>(__containers_.keys.max_size(), __containers_.values.max_size());
   }
 @@ -481,7 +484,7 @@ public:
     return try_emplace(std::forward<_Kp>(__x)).first->second;
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 mapped_type& at(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 mapped_type& at(const key_type& __x) {
     auto __it = find(__x);
     if (__it == end()) {
       std::__throw_out_of_range("flat_map::at(const key_type&): Key does not exist");
 @@ -489,7 +492,7 @@ public:
     return __it->second;
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_type& at(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_type& at(const key_type& __x) const {
     auto __it = find(__x);
     if (__it == end()) {
       std::__throw_out_of_range("flat_map::at(const key_type&) const: Key does not exist");
 @@ -499,7 +502,7 @@ public:
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 mapped_type& at(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 mapped_type& at(const _Kp& __x) {
     auto __it = find(__x);
     if (__it == end()) {
       std::__throw_out_of_range("flat_map::at(const K&): Key does not exist");
 @@ -509,7 +512,7 @@ public:
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_type& at(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_type& at(const _Kp& __x) const {
     auto __it = find(__x);
     if (__it == end()) {
       std::__throw_out_of_range("flat_map::at(const K&) const: Key does not exist");
 @@ -589,6 +592,15 @@ public:
     __append_sort_merge_unique</*WasSorted = */ false>(ranges::begin(__range), ranges::end(__range));
   }
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert_range(sorted_unique_t, _Range&& __range) {
+    if constexpr (ranges::sized_range<_Range>) {
+      __reserve(ranges::size(__range));
+    }
+    __append_sort_merge_unique</*WasSorted = */ true>(ranges::begin(__range), ranges::end(__range));
+  }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert(initializer_list<value_type> __il) {
     insert(__il.begin(), __il.end());
   }
 @@ -597,7 +609,7 @@ public:
     insert(sorted_unique, __il.begin(), __il.end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 containers extract() && {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 containers extract() && {
     auto __guard = std::__make_scope_guard([&]() noexcept { clear() /* noexcept */; });
     auto __ret   = std::move(__containers_);
     return __ret;
 @@ -738,14 +750,17 @@ public:
     return iterator(std::move(__key_it), std::move(__mapped_it));
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void swap(flat_map& __y) noexcept {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
-    // warning: The spec has unconditional noexcept, which means that
+  swap(flat_map& __y) noexcept(is_nothrow_swappable_v<key_container_type> &&
-    // if any of the following functions throw an exception,
+                               is_nothrow_swappable_v<mapped_container_type> && is_nothrow_swappable_v<key_compare>) {
-    // std::terminate will be called.
+    auto __on_failure = std::__make_exception_guard([&]() noexcept {
-    // This is discussed in P2767, which hasn't been voted on yet.
+      clear() /* noexcept */;
+      __y.clear() /* noexcept */;
+    });
     ranges::swap(__compare_, __y.__compare_);
     ranges::swap(__containers_.keys, __y.__containers_.keys);
     ranges::swap(__containers_.values, __y.__containers_.values);
+    __on_failure.__complete();
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void clear() noexcept {
 @@ -754,116 +769,121 @@ public:
   }
   // observers
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 key_compare key_comp() const { return __compare_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 key_compare key_comp() const { return __compare_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare value_comp() const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare value_comp() const {
     return value_compare(__compare_);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const key_container_type& keys() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const key_container_type& keys() const noexcept {
     return __containers_.keys;
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_container_type& values() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_container_type&
+  values() const noexcept {
     return __containers_.values;
   }
   // map operations
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const key_type& __x) {
     return __find_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const key_type& __x) const {
     return __find_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const _Kp& __x) {
     return __find_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const _Kp& __x) const {
     return __find_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const key_type& __x) const {
     return contains(__x) ? 1 : 0;
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const _Kp& __x) const {
     return contains(__x) ? 1 : 0;
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const key_type& __x) const {
     return find(__x) != end();
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const _Kp& __x) const {
     return find(__x) != end();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const key_type& __x) {
     return __lower_bound<iterator>(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  lower_bound(const key_type& __x) const {
     return __lower_bound<const_iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const _Kp& __x) {
     return __lower_bound<iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const _Kp& __x) const {
     return __lower_bound<const_iterator>(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const key_type& __x) {
     return __upper_bound<iterator>(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  upper_bound(const key_type& __x) const {
     return __upper_bound<const_iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const _Kp& __x) {
     return __upper_bound<iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const _Kp& __x) const {
     return __upper_bound<const_iterator>(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator> equal_range(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const key_type& __x) {
     return __equal_range_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
   equal_range(const key_type& __x) const {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator> equal_range(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const _Kp& __x) {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
   equal_range(const _Kp& __x) const {
     return __equal_range_impl(*this, __x);
   }
 @@ -878,7 +898,8 @@ public:
         __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
   }
-  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void swap(flat_map& __x, flat_map& __y) noexcept {
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  swap(flat_map& __x, flat_map& __y) noexcept(noexcept(__x.swap(__y))) {
     __x.swap(__y);
   }
 @@ -913,7 +934,7 @@ private:
         __compare_(std::forward<_CompArg>(__comp)...) {}
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool __is_sorted_and_unique(auto&& __key_container) const {
-    auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) { return !__compare_(__x, __y); };
+    auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) -> bool { return !__compare_(__x, __y); };
     return ranges::adjacent_find(__key_container, __greater_or_equal_to) == ranges::end(__key_container);
   }
 @@ -946,7 +967,7 @@ private:
       auto __zv                  = ranges::views::zip(__containers_.keys, __containers_.values);
       auto __append_start_offset = __containers_.keys.size() - __num_of_appended;
       auto __end                 = __zv.end();
-      auto __compare_key         = [this](const auto& __p1, const auto& __p2) {
+      auto __compare_key         = [this](const auto& __p1, const auto& __p2) -> bool {
         return __compare_(std::get<0>(__p1), std::get<0>(__p2));
       };
       if constexpr (!_WasSorted) {
 @@ -1125,8 +1146,7 @@ private:
 };
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -1139,7 +1159,7 @@ flat_map(_KeyContainer, _MappedContainer, _Compare = _Compare())
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
   requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value)
+           !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer>)
 flat_map(_KeyContainer, _MappedContainer, _Allocator)
     -> flat_map<typename _KeyContainer::value_type,
                 typename _MappedContainer::value_type,
 @@ -1148,9 +1168,8 @@ flat_map(_KeyContainer, _MappedContainer, _Allocator)
                 _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> &&
+           uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           uses_allocator_v<_MappedContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -1162,8 +1181,7 @@ flat_map(_KeyContainer, _MappedContainer, _Compare, _Allocator)
                 _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -1176,7 +1194,7 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare = _Compare()
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
   requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value)
+           !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer>)
 flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator)
     -> flat_map<typename _KeyContainer::value_type,
                 typename _MappedContainer::value_type,
 @@ -1185,9 +1203,8 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Allocator)
                 _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> &&
+           uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           uses_allocator_v<_MappedContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -1199,19 +1216,19 @@ flat_map(sorted_unique_t, _KeyContainer, _MappedContainer, _Compare, _Allocator)
                 _MappedContainer>;
 template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_map(_InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
 template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_map(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
 template <ranges::input_range _Range,
           class _Compare   = less<__range_key_type<_Range>>,
           class _Allocator = allocator<byte>,
-          class            = __enable_if_t<!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value>>
+          class            = __enable_if_t<!__is_allocator_v<_Compare> && __is_allocator_v<_Allocator>>>
 flat_map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_map<
     __range_key_type<_Range>,
     __range_mapped_type<_Range>,
 @@ -1219,7 +1236,7 @@ flat_map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator(
     vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>,
     vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>;
-template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator_v<_Allocator>>>
 flat_map(from_range_t, _Range&&, _Allocator) -> flat_map<
     __range_key_type<_Range>,
     __range_mapped_type<_Range>,
 @@ -1228,11 +1245,11 @@ flat_map(from_range_t, _Range&&, _Allocator) -> flat_map<
     vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>;
 template <class _Key, class _Tp, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_map<_Key, _Tp, _Compare>;
 template <class _Key, class _Tp, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_map(sorted_unique_t, initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_map<_Key, _Tp, _Compare>;
 template <class _Key, class _Tp, class _Compare, class _KeyContainer, class _MappedContainer, class _Allocator>

lib/libcxx/include/__flat_map/flat_multimap.h+251-172

 @@ -22,7 +22,6 @@
 #include <__algorithm/upper_bound.h>
 #include <__assert>
 #include <__compare/synth_three_way.h>
-#include <__concepts/convertible_to.h>
 #include <__concepts/swappable.h>
 #include <__config>
 #include <__cstddef/byte.h>
 @@ -30,7 +29,6 @@
 #include <__flat_map/key_value_iterator.h>
 #include <__flat_map/sorted_equivalent.h>
 #include <__flat_map/utils.h>
-#include <__functional/invoke.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__fwd/vector.h>
 @@ -47,7 +45,7 @@
 #include <__ranges/container_compatible_range.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/from_range.h>
-#include <__ranges/ref_view.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
 #include <__ranges/zip_view.h>
 @@ -57,14 +55,12 @@
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_same.h>
-#include <__type_traits/maybe_const.h>
 #include <__utility/exception_guard.h>
 #include <__utility/move.h>
 #include <__utility/pair.h>
 #include <__utility/scope_guard.h>
 #include <__vector/vector.h>
 #include <initializer_list>
-#include <stdexcept>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 @@ -114,11 +110,12 @@ public:
   class value_compare {
   private:
     _LIBCPP_NO_UNIQUE_ADDRESS key_compare __comp_;
-    _LIBCPP_HIDE_FROM_ABI value_compare(key_compare __c) : __comp_(__c) {}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare(key_compare __c) : __comp_(__c) {}
     friend flat_multimap;
   public:
-    _LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool
+    operator()(const_reference __x, const_reference __y) const {
       return __comp_(__x.first, __y.first);
     }
   };
 @@ -137,17 +134,17 @@ private:
 public:
   // [flat.map.cons], construct/copy/destroy
-  _LIBCPP_HIDE_FROM_ABI flat_multimap() noexcept(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap() noexcept(
       is_nothrow_default_constructible_v<_KeyContainer> && is_nothrow_default_constructible_v<_MappedContainer> &&
       is_nothrow_default_constructible_v<_Compare>)
       : __containers_(), __compare_() {}
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(const flat_multimap&) = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(const flat_multimap&) = default;
   // The copy/move constructors are not specified in the spec, which means they should be defaulted.
   // However, the move constructor can potentially leave a moved-from object in an inconsistent
   // state if an exception is thrown.
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(flat_multimap&& __other) noexcept(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(flat_multimap&& __other) noexcept(
       is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_MappedContainer> &&
       is_nothrow_move_constructible_v<_Compare>)
 #  if _LIBCPP_HAS_EXCEPTIONS
 @@ -168,7 +165,8 @@ public:
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(const flat_multimap& __other, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(const flat_multimap& __other, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_tag{},
                       __alloc,
                       __other.__containers_.keys,
 @@ -177,7 +175,7 @@ public:
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(flat_multimap&& __other, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(flat_multimap&& __other, const _Allocator& __alloc)
 #  if _LIBCPP_HAS_EXCEPTIONS
       try
 #  endif // _LIBCPP_HAS_EXCEPTIONS
 @@ -194,7 +192,7 @@ public:
 #  endif // _LIBCPP_HAS_EXCEPTIONS
   }
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
       key_container_type __key_cont, mapped_container_type __mapped_cont, const key_compare& __comp = key_compare())
       : __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
 @@ -204,7 +202,7 @@ public:
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
       const key_container_type& __key_cont, const mapped_container_type& __mapped_cont, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
 @@ -214,22 +212,22 @@ public:
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
-  flat_multimap(const key_container_type& __key_cont,
+      const key_container_type& __key_cont,
-                const mapped_container_type& __mapped_cont,
+      const mapped_container_type& __mapped_cont,
-                const key_compare& __comp,
+      const key_compare& __comp,
-                const _Allocator& __alloc)
+      const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
                                      "flat_multimap keys and mapped containers have different size");
     __sort();
   }
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
-  flat_multimap(sorted_equivalent_t,
+      sorted_equivalent_t,
-                key_container_type __key_cont,
+      key_container_type __key_cont,
-                mapped_container_type __mapped_cont,
+      mapped_container_type __mapped_cont,
-                const key_compare& __comp = key_compare())
+      const key_compare& __comp = key_compare())
       : __containers_{.keys = std::move(__key_cont), .values = std::move(__mapped_cont)}, __compare_(__comp) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
                                      "flat_multimap keys and mapped containers have different size");
 @@ -238,11 +236,11 @@ public:
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
-  flat_multimap(sorted_equivalent_t,
+      sorted_equivalent_t,
-                const key_container_type& __key_cont,
+      const key_container_type& __key_cont,
-                const mapped_container_type& __mapped_cont,
+      const mapped_container_type& __mapped_cont,
-                const _Allocator& __alloc)
+      const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
                                      "flat_multimap keys and mapped containers have different size");
 @@ -251,33 +249,35 @@ public:
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
-  flat_multimap(sorted_equivalent_t,
+      sorted_equivalent_t,
-                const key_container_type& __key_cont,
+      const key_container_type& __key_cont,
-                const mapped_container_type& __mapped_cont,
+      const mapped_container_type& __mapped_cont,
-                const key_compare& __comp,
+      const key_compare& __comp,
-                const _Allocator& __alloc)
+      const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_tag{}, __alloc, __key_cont, __mapped_cont, __comp) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(__containers_.keys.size() == __containers_.values.size(),
                                      "flat_multimap keys and mapped containers have different size");
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(__is_sorted(__containers_.keys), "Key container is not sorted");
   }
-  _LIBCPP_HIDE_FROM_ABI explicit flat_multimap(const key_compare& __comp) : __containers_(), __compare_(__comp) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 explicit flat_multimap(const key_compare& __comp)
+      : __containers_(), __compare_(__comp) {}
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(const key_compare& __comp, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(const key_compare& __comp, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {}
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI explicit flat_multimap(const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 explicit flat_multimap(const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc) {}
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multimap(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
       : __containers_(), __compare_(__comp) {
     insert(__first, __last);
 @@ -285,7 +285,7 @@ public:
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multimap(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
     insert(__first, __last);
 @@ -293,91 +293,99 @@ public:
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc) {
     insert(__first, __last);
   }
   template <_ContainerCompatibleRange<value_type> _Range>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(from_range_t __fr, _Range&& __rg)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(from_range_t __fr, _Range&& __rg)
       : flat_multimap(__fr, std::forward<_Range>(__rg), key_compare()) {}
   template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(from_range_t, _Range&& __rg, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(from_range_t, _Range&& __rg, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc) {
     insert_range(std::forward<_Range>(__rg));
   }
   template <_ContainerCompatibleRange<value_type> _Range>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(from_range_t, _Range&& __rg, const key_compare& __comp) : flat_multimap(__comp) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(from_range_t, _Range&& __rg, const key_compare& __comp)
+      : flat_multimap(__comp) {
     insert_range(std::forward<_Range>(__rg));
   }
   template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
     insert_range(std::forward<_Range>(__rg));
   }
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
       sorted_equivalent_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
       : __containers_(), __compare_(__comp) {
     insert(sorted_equivalent, __first, __last);
   }
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
-  flat_multimap(sorted_equivalent_t,
+      sorted_equivalent_t,
-                _InputIterator __first,
+      _InputIterator __first,
-                _InputIterator __last,
+      _InputIterator __last,
-                const key_compare& __comp,
+      const key_compare& __comp,
-                const _Allocator& __alloc)
+      const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc, __comp) {
     insert(sorted_equivalent, __first, __last);
   }
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && __allocator_ctor_constraint<_Allocator>)
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multimap(sorted_equivalent_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
       : flat_multimap(__ctor_uses_allocator_empty_tag{}, __alloc) {
     insert(sorted_equivalent, __first, __last);
   }
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
       : flat_multimap(__il.begin(), __il.end(), __comp) {}
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multimap(initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
       : flat_multimap(__il.begin(), __il.end(), __comp, __alloc) {}
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(initializer_list<value_type> __il, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(initializer_list<value_type> __il, const _Allocator& __alloc)
       : flat_multimap(__il.begin(), __il.end(), __alloc) {}
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multimap(sorted_equivalent_t, initializer_list<value_type> __il, const key_compare& __comp = key_compare())
       : flat_multimap(sorted_equivalent, __il.begin(), __il.end(), __comp) {}
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
       sorted_equivalent_t, initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
       : flat_multimap(sorted_equivalent, __il.begin(), __il.end(), __comp, __alloc) {}
   template <class _Allocator>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(sorted_equivalent_t, initializer_list<value_type> __il, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(sorted_equivalent_t, initializer_list<value_type> __il, const _Allocator& __alloc)
       : flat_multimap(sorted_equivalent, __il.begin(), __il.end(), __alloc) {}
-  _LIBCPP_HIDE_FROM_ABI flat_multimap& operator=(initializer_list<value_type> __il) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap& operator=(initializer_list<value_type> __il) {
     clear();
     insert(__il);
     return *this;
 @@ -386,9 +394,9 @@ public:
   // copy/move assignment are not specified in the spec (defaulted)
   // but move assignment can potentially leave moved from object in an inconsistent
   // state if an exception is thrown
-  _LIBCPP_HIDE_FROM_ABI flat_multimap& operator=(const flat_multimap&) = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap& operator=(const flat_multimap&) = default;
-  _LIBCPP_HIDE_FROM_ABI flat_multimap& operator=(flat_multimap&& __other) noexcept(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap& operator=(flat_multimap&& __other) noexcept(
       is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_MappedContainer> &&
       is_nothrow_move_assignable_v<_Compare>) {
     auto __clear_other_guard = std::__make_scope_guard([&]() noexcept { __other.clear() /* noexcept */; });
 @@ -400,38 +408,58 @@ public:
   }
   // iterators
-  _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator begin() noexcept {
     return iterator(__containers_.keys.begin(), __containers_.values.begin());
   }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator begin() const noexcept {
     return const_iterator(__containers_.keys.begin(), __containers_.values.begin());
   }
-  _LIBCPP_HIDE_FROM_ABI iterator end() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator end() noexcept {
     return iterator(__containers_.keys.end(), __containers_.values.end());
   }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator end() const noexcept {
     return const_iterator(__containers_.keys.end(), __containers_.values.end());
   }
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rbegin() noexcept {
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+    return reverse_iterator(end());
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rend() noexcept {
+    return reverse_iterator(begin());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const noexcept { return begin(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cbegin() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const noexcept { return end(); }
+    return begin();
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cend() const noexcept {
+    return end();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
   // [flat.map.capacity], capacity
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __containers_.keys.empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool empty() const noexcept {
+    return __containers_.keys.empty();
+  }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const noexcept { return __containers_.keys.size(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type size() const noexcept {
+    return __containers_.keys.size();
+  }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type max_size() const noexcept {
     return std::min<size_type>(__containers_.keys.max_size(), __containers_.values.max_size());
   }
 @@ -439,7 +467,7 @@ public:
   template <class... _Args>
     requires is_constructible_v<pair<key_type, mapped_type>, _Args...> && is_move_constructible_v<key_type> &&
              is_move_constructible_v<mapped_type>
-  _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator emplace(_Args&&... __args) {
     std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
     auto __key_it    = std::upper_bound(__containers_.keys.begin(), __containers_.keys.end(), __pair.first, __compare_);
     auto __mapped_it = __corresponding_mapped_it(*this, __key_it);
 @@ -450,7 +478,7 @@ public:
   template <class... _Args>
     requires is_constructible_v<pair<key_type, mapped_type>, _Args...>
-  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
     std::pair<key_type, mapped_type> __pair(std::forward<_Args>(__args)...);
     auto __prev_larger  = __hint != cbegin() && __compare_(__pair.first, (__hint - 1)->first);
 @@ -490,33 +518,35 @@ public:
         *this, __key_iter, __mapped_iter, std::move(__pair.first), std::move(__pair.second));
   }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return emplace(__x); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const value_type& __x) { return emplace(__x); }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __x) { return emplace(std::move(__x)); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(value_type&& __x) {
+    return emplace(std::move(__x));
+  }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, const value_type& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const_iterator __hint, const value_type& __x) {
     return emplace_hint(__hint, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, value_type&& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const_iterator __hint, value_type&& __x) {
     return emplace_hint(__hint, std::move(__x));
   }
   template <class _PairLike>
     requires is_constructible_v<pair<key_type, mapped_type>, _PairLike>
-  _LIBCPP_HIDE_FROM_ABI iterator insert(_PairLike&& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(_PairLike&& __x) {
     return emplace(std::forward<_PairLike>(__x));
   }
   template <class _PairLike>
     requires is_constructible_v<pair<key_type, mapped_type>, _PairLike>
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, _PairLike&& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const_iterator __hint, _PairLike&& __x) {
     return emplace_hint(__hint, std::forward<_PairLike>(__x));
   }
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert(_InputIterator __first, _InputIterator __last) {
     if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
       __reserve(__last - __first);
     }
 @@ -525,7 +555,8 @@ public:
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI void insert(sorted_equivalent_t, _InputIterator __first, _InputIterator __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  insert(sorted_equivalent_t, _InputIterator __first, _InputIterator __last) {
     if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
       __reserve(__last - __first);
     }
 @@ -534,7 +565,7 @@ public:
   }
   template <_ContainerCompatibleRange<value_type> _Range>
-  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert_range(_Range&& __range) {
     if constexpr (ranges::sized_range<_Range>) {
       __reserve(ranges::size(__range));
     }
 @@ -542,19 +573,32 @@ public:
     __append_sort_merge</*WasSorted = */ false>(ranges::begin(__range), ranges::end(__range));
   }
-  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert_range(sorted_equivalent_t, _Range&& __range) {
+    if constexpr (ranges::sized_range<_Range>) {
+      __reserve(ranges::size(__range));
+    }
+    __append_sort_merge</*WasSorted = */ true>(ranges::begin(__range), ranges::end(__range));
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert(initializer_list<value_type> __il) {
+    insert(__il.begin(), __il.end());
+  }
-  _LIBCPP_HIDE_FROM_ABI void insert(sorted_equivalent_t, initializer_list<value_type> __il) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  insert(sorted_equivalent_t, initializer_list<value_type> __il) {
     insert(sorted_equivalent, __il.begin(), __il.end());
   }
-  _LIBCPP_HIDE_FROM_ABI containers extract() && {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 containers extract() && {
     auto __guard = std::__make_scope_guard([&]() noexcept { clear() /* noexcept */; });
     auto __ret   = std::move(__containers_);
     return __ret;
   }
-  _LIBCPP_HIDE_FROM_ABI void replace(key_container_type&& __key_cont, mapped_container_type&& __mapped_cont) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  replace(key_container_type&& __key_cont, mapped_container_type&& __mapped_cont) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(
         __key_cont.size() == __mapped_cont.size(), "flat_multimap keys and mapped containers have different size");
 @@ -565,15 +609,15 @@ public:
     __guard.__complete();
   }
-  _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator erase(iterator __position) {
     return __erase(__position.__key_iter_, __position.__mapped_iter_);
   }
-  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __position) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator erase(const_iterator __position) {
     return __erase(__position.__key_iter_, __position.__mapped_iter_);
   }
-  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type erase(const key_type& __x) {
     auto [__first, __last] = equal_range(__x);
     auto __res             = __last - __first;
     erase(__first, __last);
 @@ -583,14 +627,14 @@ public:
   template <class _Kp>
     requires(__is_compare_transparent && !is_convertible_v<_Kp &&, iterator> &&
              !is_convertible_v<_Kp &&, const_iterator>)
-  _LIBCPP_HIDE_FROM_ABI size_type erase(_Kp&& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type erase(_Kp&& __x) {
     auto [__first, __last] = equal_range(__x);
     auto __res             = __last - __first;
     erase(__first, __last);
     return __res;
   }
-  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator erase(const_iterator __first, const_iterator __last) {
     auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     auto __key_it     = __containers_.keys.erase(__first.__key_iter_, __last.__key_iter_);
     auto __mapped_it  = __containers_.values.erase(__first.__mapped_iter_, __last.__mapped_iter_);
 @@ -598,146 +642,178 @@ public:
     return iterator(std::move(__key_it), std::move(__mapped_it));
   }
-  _LIBCPP_HIDE_FROM_ABI void swap(flat_multimap& __y) noexcept {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void swap(flat_multimap& __y) noexcept(
-    // warning: The spec has unconditional noexcept, which means that
+      is_nothrow_swappable_v<key_container_type> && is_nothrow_swappable_v<mapped_container_type> &&
-    // if any of the following functions throw an exception,
+      is_nothrow_swappable_v<key_compare>) {
-    // std::terminate will be called
+    auto __on_failure = std::__make_exception_guard([&]() noexcept {
+      clear() /* noexcept */;
+      __y.clear() /* noexcept */;
+    });
     ranges::swap(__compare_, __y.__compare_);
     ranges::swap(__containers_.keys, __y.__containers_.keys);
     ranges::swap(__containers_.values, __y.__containers_.values);
+    __on_failure.__complete();
   }
-  _LIBCPP_HIDE_FROM_ABI void clear() noexcept {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void clear() noexcept {
     __containers_.keys.clear();
     __containers_.values.clear();
   }
   // observers
-  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 key_compare key_comp() const { return __compare_; }
-  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__compare_); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare value_comp() const {
+    return value_compare(__compare_);
+  }
-  _LIBCPP_HIDE_FROM_ABI const key_container_type& keys() const noexcept { return __containers_.keys; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const key_container_type& keys() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI const mapped_container_type& values() const noexcept { return __containers_.values; }
+    return __containers_.keys;
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const mapped_container_type&
+  values() const noexcept {
+    return __containers_.values;
+  }
   // map operations
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __x) { return __find_impl(*this, __x); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const key_type& __x) {
+    return __find_impl(*this, __x);
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __x) const { return __find_impl(*this, __x); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const key_type& __x) const {
+    return __find_impl(*this, __x);
+  }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const _Kp& __x) {
     return __find_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const _Kp& __x) const {
     return __find_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const key_type& __x) const {
     auto [__first, __last] = equal_range(__x);
     return __last - __first;
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const _Kp& __x) const {
     auto [__first, __last] = equal_range(__x);
     return __last - __first;
   }
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const key_type& __x) const {
+    return find(__x) != end();
+  }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const _Kp& __x) const {
     return find(__x) != end();
   }
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) { return __lower_bound<iterator>(*this, __x); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const key_type& __x) {
+    return __lower_bound<iterator>(*this, __x);
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  lower_bound(const key_type& __x) const {
     return __lower_bound<const_iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const _Kp& __x) {
     return __lower_bound<iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const _Kp& __x) const {
     return __lower_bound<const_iterator>(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) { return __upper_bound<iterator>(*this, __x); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const key_type& __x) {
+    return __upper_bound<iterator>(*this, __x);
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  upper_bound(const key_type& __x) const {
     return __upper_bound<const_iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const _Kp& __x) {
     return __upper_bound<iterator>(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const _Kp& __x) const {
     return __upper_bound<const_iterator>(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const key_type& __x) {
     return __equal_range_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  equal_range(const key_type& __x) const {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const _Kp& __x) {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_compare_transparent
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  equal_range(const _Kp& __x) const {
     return __equal_range_impl(*this, __x);
   }
-  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const flat_multimap& __x, const flat_multimap& __y) {
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool
+  operator==(const flat_multimap& __x, const flat_multimap& __y) {
     return ranges::equal(__x, __y);
   }
-  friend _LIBCPP_HIDE_FROM_ABI auto operator<=>(const flat_multimap& __x, const flat_multimap& __y) {
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 auto
+  operator<=>(const flat_multimap& __x, const flat_multimap& __y) {
     return std::lexicographical_compare_three_way(
         __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
   }
-  friend _LIBCPP_HIDE_FROM_ABI void swap(flat_multimap& __x, flat_multimap& __y) noexcept { __x.swap(__y); }
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  swap(flat_multimap& __x, flat_multimap& __y) noexcept(noexcept(__x.swap(__y))) {
+    __x.swap(__y);
+  }
 private:
   struct __ctor_uses_allocator_tag {
-    explicit _LIBCPP_HIDE_FROM_ABI __ctor_uses_allocator_tag() = default;
+    explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 __ctor_uses_allocator_tag() = default;
   };
   struct __ctor_uses_allocator_empty_tag {
-    explicit _LIBCPP_HIDE_FROM_ABI __ctor_uses_allocator_empty_tag() = default;
+    explicit _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 __ctor_uses_allocator_empty_tag() = default;
   };
   template <class _Allocator, class _KeyCont, class _MappedCont, class... _CompArg>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multimap(
-  flat_multimap(__ctor_uses_allocator_tag,
+      __ctor_uses_allocator_tag,
-                const _Allocator& __alloc,
+      const _Allocator& __alloc,
-                _KeyCont&& __key_cont,
+      _KeyCont&& __key_cont,
-                _MappedCont&& __mapped_cont,
+      _MappedCont&& __mapped_cont,
-                _CompArg&&... __comp)
+      _CompArg&&... __comp)
       : __containers_{.keys = std::make_obj_using_allocator<key_container_type>(
                           __alloc, std::forward<_KeyCont>(__key_cont)),
                       .values = std::make_obj_using_allocator<mapped_container_type>(
 @@ -746,36 +822,39 @@ private:
   template <class _Allocator, class... _CompArg>
     requires __allocator_ctor_constraint<_Allocator>
-  _LIBCPP_HIDE_FROM_ABI flat_multimap(__ctor_uses_allocator_empty_tag, const _Allocator& __alloc, _CompArg&&... __comp)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multimap(__ctor_uses_allocator_empty_tag, const _Allocator& __alloc, _CompArg&&... __comp)
       : __containers_{.keys   = std::make_obj_using_allocator<key_container_type>(__alloc),
                       .values = std::make_obj_using_allocator<mapped_container_type>(__alloc)},
         __compare_(std::forward<_CompArg>(__comp)...) {}
-  _LIBCPP_HIDE_FROM_ABI bool __is_sorted(auto&& __key_container) const {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool __is_sorted(auto&& __key_container) const {
     return ranges::is_sorted(__key_container, __compare_);
   }
-  _LIBCPP_HIDE_FROM_ABI void __sort() {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void __sort() {
     auto __zv = ranges::views::zip(__containers_.keys, __containers_.values);
     ranges::sort(__zv, __compare_, [](const auto& __p) -> decltype(auto) { return std::get<0>(__p); });
   }
   template <class _Self, class _KeyIter>
-  _LIBCPP_HIDE_FROM_ABI static auto __corresponding_mapped_it(_Self&& __self, _KeyIter&& __key_iter) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static auto
+  __corresponding_mapped_it(_Self&& __self, _KeyIter&& __key_iter) {
     return __self.__containers_.values.begin() +
            static_cast<ranges::range_difference_t<mapped_container_type>>(
                ranges::distance(__self.__containers_.keys.begin(), __key_iter));
   }
   template <bool _WasSorted, class _InputIterator, class _Sentinel>
-  _LIBCPP_HIDE_FROM_ABI void __append_sort_merge(_InputIterator __first, _Sentinel __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  __append_sort_merge(_InputIterator __first, _Sentinel __last) {
     auto __on_failure     = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     size_t __num_appended = __flat_map_utils::__append(*this, std::move(__first), std::move(__last));
     if (__num_appended != 0) {
       auto __zv                  = ranges::views::zip(__containers_.keys, __containers_.values);
       auto __append_start_offset = __containers_.keys.size() - __num_appended;
       auto __end                 = __zv.end();
-      auto __compare_key         = [this](const auto& __p1, const auto& __p2) {
+      auto __compare_key         = [this](const auto& __p1, const auto& __p2) -> bool {
         return __compare_(std::get<0>(__p1), std::get<0>(__p2));
       };
       if constexpr (!_WasSorted) {
 @@ -791,7 +870,7 @@ private:
   }
   template <class _Self, class _Kp>
-  _LIBCPP_HIDE_FROM_ABI static auto __find_impl(_Self&& __self, const _Kp& __key) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static auto __find_impl(_Self&& __self, const _Kp& __key) {
     auto __it   = __self.lower_bound(__key);
     auto __last = __self.end();
     if (__it == __last || __self.__compare_(__key, __it->first)) {
 @@ -801,7 +880,7 @@ private:
   }
   template <class _Self, class _Kp>
-  _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
     auto [__key_first, __key_last] =
         std::equal_range(__self.__containers_.keys.begin(), __self.__containers_.keys.end(), __key, __self.__compare_);
 @@ -811,7 +890,7 @@ private:
   }
   template <class _Res, class _Self, class _Kp>
-  _LIBCPP_HIDE_FROM_ABI static _Res __lower_bound(_Self&& __self, _Kp& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static _Res __lower_bound(_Self&& __self, _Kp& __x) {
     auto __key_iter =
         std::lower_bound(__self.__containers_.keys.begin(), __self.__containers_.keys.end(), __x, __self.__compare_);
     auto __mapped_iter = __corresponding_mapped_it(__self, __key_iter);
 @@ -819,14 +898,14 @@ private:
   }
   template <class _Res, class _Self, class _Kp>
-  _LIBCPP_HIDE_FROM_ABI static _Res __upper_bound(_Self&& __self, _Kp& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static _Res __upper_bound(_Self&& __self, _Kp& __x) {
     auto __key_iter =
         std::upper_bound(__self.__containers_.keys.begin(), __self.__containers_.keys.end(), __x, __self.__compare_);
     auto __mapped_iter = __corresponding_mapped_it(__self, __key_iter);
     return _Res(std::move(__key_iter), std::move(__mapped_iter));
   }
-  _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void __reserve(size_t __size) {
     if constexpr (__container_traits<_KeyContainer>::__reservable) {
       __containers_.keys.reserve(__size);
     }
 @@ -837,7 +916,8 @@ private:
   }
   template <class _KIter, class _MIter>
-  _LIBCPP_HIDE_FROM_ABI iterator __erase(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator
+  __erase(_KIter __key_iter_to_remove, _MIter __mapped_iter_to_remove) {
     auto __on_failure  = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     auto __key_iter    = __containers_.keys.erase(__key_iter_to_remove);
     auto __mapped_iter = __containers_.values.erase(__mapped_iter_to_remove);
 @@ -847,7 +927,8 @@ private:
   template <class _Key2, class _Tp2, class _Compare2, class _KeyContainer2, class _MappedContainer2, class _Predicate>
   friend typename flat_multimap<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>::size_type
-  erase_if(flat_multimap<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate);
+      _LIBCPP_CONSTEXPR_SINCE_CXX26
+      erase_if(flat_multimap<_Key2, _Tp2, _Compare2, _KeyContainer2, _MappedContainer2>&, _Predicate);
   friend __flat_map_utils;
 @@ -855,8 +936,9 @@ private:
   _LIBCPP_NO_UNIQUE_ADDRESS key_compare __compare_;
   struct __key_equiv {
-    _LIBCPP_HIDE_FROM_ABI __key_equiv(key_compare __c) : __comp_(__c) {}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 __key_equiv(key_compare __c) : __comp_(__c) {}
-    _LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool
+    operator()(const_reference __x, const_reference __y) const {
       return !__comp_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x));
     }
     key_compare __comp_;
 @@ -864,8 +946,7 @@ private:
 };
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -878,7 +959,7 @@ flat_multimap(_KeyContainer, _MappedContainer, _Compare = _Compare())
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
   requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value)
+           !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer>)
 flat_multimap(_KeyContainer, _MappedContainer, _Allocator)
     -> flat_multimap<typename _KeyContainer::value_type,
                      typename _MappedContainer::value_type,
 @@ -887,9 +968,8 @@ flat_multimap(_KeyContainer, _MappedContainer, _Allocator)
                      _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> &&
+           uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           uses_allocator_v<_MappedContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -901,8 +981,7 @@ flat_multimap(_KeyContainer, _MappedContainer, _Compare, _Allocator)
                      _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -915,7 +994,7 @@ flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare = _
 template <class _KeyContainer, class _MappedContainer, class _Allocator>
   requires(uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           !__is_allocator<_KeyContainer>::value && !__is_allocator<_MappedContainer>::value)
+           !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer>)
 flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
     -> flat_multimap<typename _KeyContainer::value_type,
                      typename _MappedContainer::value_type,
 @@ -924,9 +1003,8 @@ flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Allocator)
                      _MappedContainer>;
 template <class _KeyContainer, class _MappedContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> && !__is_allocator_v<_MappedContainer> &&
-           !__is_allocator<_MappedContainer>::value && uses_allocator_v<_KeyContainer, _Allocator> &&
+           uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator> &&
-           uses_allocator_v<_MappedContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -938,19 +1016,19 @@ flat_multimap(sorted_equivalent_t, _KeyContainer, _MappedContainer, _Compare, _A
                      _MappedContainer>;
 template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_multimap(_InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
 template <class _InputIterator, class _Compare = less<__iter_key_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_multimap(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
     -> flat_multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare>;
 template <ranges::input_range _Range,
           class _Compare   = less<__range_key_type<_Range>>,
           class _Allocator = allocator<byte>,
-          class            = __enable_if_t<!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value>>
+          class            = __enable_if_t<!__is_allocator_v<_Compare> && __is_allocator_v<_Allocator>>>
 flat_multimap(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_multimap<
     __range_key_type<_Range>,
     __range_mapped_type<_Range>,
 @@ -958,7 +1036,7 @@ flat_multimap(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Alloc
     vector<__range_key_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_key_type<_Range>>>,
     vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>;
-template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator_v<_Allocator>>>
 flat_multimap(from_range_t, _Range&&, _Allocator) -> flat_multimap<
     __range_key_type<_Range>,
     __range_mapped_type<_Range>,
 @@ -967,11 +1045,11 @@ flat_multimap(from_range_t, _Range&&, _Allocator) -> flat_multimap<
     vector<__range_mapped_type<_Range>, __allocator_traits_rebind_t<_Allocator, __range_mapped_type<_Range>>>>;
 template <class _Key, class _Tp, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_multimap(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare()) -> flat_multimap<_Key, _Tp, _Compare>;
 template <class _Key, class _Tp, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_multimap(sorted_equivalent_t, initializer_list<pair<_Key, _Tp>>, _Compare = _Compare())
     -> flat_multimap<_Key, _Tp, _Compare>;
 @@ -980,8 +1058,9 @@ struct uses_allocator<flat_multimap<_Key, _Tp, _Compare, _KeyContainer, _MappedC
     : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> && uses_allocator_v<_MappedContainer, _Allocator>> {};
 template <class _Key, class _Tp, class _Compare, class _KeyContainer, class _MappedContainer, class _Predicate>
-_LIBCPP_HIDE_FROM_ABI typename flat_multimap<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::size_type
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
-erase_if(flat_multimap<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>& __flat_multimap, _Predicate __pred) {
+    typename flat_multimap<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>::size_type
+    erase_if(flat_multimap<_Key, _Tp, _Compare, _KeyContainer, _MappedContainer>& __flat_multimap, _Predicate __pred) {
   auto __zv     = ranges::views::zip(__flat_multimap.__containers_.keys, __flat_multimap.__containers_.values);
   auto __first  = __zv.begin();
   auto __last   = __zv.end();

lib/libcxx/include/__flat_map/key_value_iterator.h-1

...	@@ -20,7 +20,6 @@	...	@@ -20,7 +20,6 @@
20	#include <__type_traits/conditional.h>	20	#include <__type_traits/conditional.h>
21	#include <__utility/forward.h>	21	#include <__utility/forward.h>
22	#include <__utility/move.h>	22	#include <__utility/move.h>
23	#include <__utility/pair.h>
24		23
25	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	24	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
26	# pragma GCC system_header	25	# pragma GCC system_header

lib/libcxx/include/__flat_map/utils.h+1

...	@@ -16,6 +16,7 @@	...	@@ -16,6 +16,7 @@
16	#include <__utility/exception_guard.h>	16	#include <__utility/exception_guard.h>
17	#include <__utility/forward.h>	17	#include <__utility/forward.h>
18	#include <__utility/move.h>	18	#include <__utility/move.h>
		19	#include <__vector/container_traits.h>
19		20
20	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
21	# pragma GCC system_header	22	# pragma GCC system_header

lib/libcxx/include/__flat_set/flat_multiset.h+211-143

 @@ -13,54 +13,41 @@
 #include <__algorithm/equal_range.h>
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/lower_bound.h>
-#include <__algorithm/min.h>
 #include <__algorithm/ranges_equal.h>
 #include <__algorithm/ranges_inplace_merge.h>
 #include <__algorithm/ranges_is_sorted.h>
 #include <__algorithm/ranges_sort.h>
-#include <__algorithm/ranges_unique.h>
 #include <__algorithm/remove_if.h>
 #include <__algorithm/upper_bound.h>
 #include <__assert>
 #include <__compare/synth_three_way.h>
-#include <__concepts/convertible_to.h>
 #include <__concepts/swappable.h>
 #include <__config>
-#include <__cstddef/byte.h>
-#include <__cstddef/ptrdiff_t.h>
-#include <__flat_map/key_value_iterator.h>
 #include <__flat_map/sorted_equivalent.h>
 #include <__flat_set/ra_iterator.h>
 #include <__flat_set/utils.h>
-#include <__functional/invoke.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__fwd/vector.h>
 #include <__iterator/concepts.h>
-#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/prev.h>
-#include <__iterator/ranges_iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/uses_allocator.h>
 #include <__memory/uses_allocator_construction.h>
-#include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/container_compatible_range.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/from_range.h>
-#include <__ranges/ref_view.h>
+#include <__ranges/range_adaptor.h>
 #include <__ranges/size.h>
 #include <__ranges/subrange.h>
-#include <__ranges/zip_view.h>
-#include <__type_traits/conjunction.h>
 #include <__type_traits/container_traits.h>
 #include <__type_traits/invoke.h>
 #include <__type_traits/is_allocator.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/is_same.h>
-#include <__type_traits/maybe_const.h>
 #include <__utility/as_const.h>
 #include <__utility/exception_guard.h>
 #include <__utility/move.h>
 @@ -108,16 +95,16 @@ public:
 public:
   // [flat.multiset.cons], constructors
-  _LIBCPP_HIDE_FROM_ABI flat_multiset() noexcept(is_nothrow_default_constructible_v<_KeyContainer> &&
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset() noexcept(
-                                                 is_nothrow_default_constructible_v<_Compare>)
+      is_nothrow_default_constructible_v<_KeyContainer> && is_nothrow_default_constructible_v<_Compare>)
       : __keys_(), __compare_() {}
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(const flat_multiset&) = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(const flat_multiset&) = default;
   // The copy/move constructors are not specified in the spec, which means they should be defaulted.
   // However, the move constructor can potentially leave a moved-from object in an inconsistent
   // state if an exception is thrown.
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(flat_multiset&& __other) noexcept(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(flat_multiset&& __other) noexcept(
       is_nothrow_move_constructible_v<_KeyContainer> && is_nothrow_move_constructible_v<_Compare>)
 #  if _LIBCPP_HAS_EXCEPTIONS
       try
 @@ -134,14 +121,16 @@ public:
 #  endif // _LIBCPP_HAS_EXCEPTIONS
   }
-  _LIBCPP_HIDE_FROM_ABI explicit flat_multiset(const key_compare& __comp) : __keys_(), __compare_(__comp) {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 explicit flat_multiset(const key_compare& __comp)
+      : __keys_(), __compare_(__comp) {}
-  _LIBCPP_HIDE_FROM_ABI explicit flat_multiset(container_type __keys, const key_compare& __comp = key_compare())
+  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX26 explicit flat_multiset(container_type __keys, const key_compare& __comp = key_compare())
       : __keys_(std::move(__keys)), __compare_(__comp) {
     ranges::sort(__keys_, __compare_);
   }
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(sorted_equivalent_t, container_type __keys, const key_compare& __comp = key_compare())
       : __keys_(std::move(__keys)), __compare_(__comp) {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted");
 @@ -149,7 +138,7 @@ public:
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(_InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
       : __keys_(), __compare_(__comp) {
     insert(__first, __last);
 @@ -157,48 +146,53 @@ public:
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(
       sorted_equivalent_t, _InputIterator __first, _InputIterator __last, const key_compare& __comp = key_compare())
       : __keys_(__first, __last), __compare_(__comp) {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted");
   }
   template <_ContainerCompatibleRange<value_type> _Range>
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(from_range_t __fr, _Range&& __rg)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(from_range_t __fr, _Range&& __rg)
       : flat_multiset(__fr, std::forward<_Range>(__rg), key_compare()) {}
   template <_ContainerCompatibleRange<value_type> _Range>
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(from_range_t, _Range&& __rg, const key_compare& __comp) : flat_multiset(__comp) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(from_range_t, _Range&& __rg, const key_compare& __comp)
+      : flat_multiset(__comp) {
     insert_range(std::forward<_Range>(__rg));
   }
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
       : flat_multiset(__il.begin(), __il.end(), __comp) {}
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(sorted_equivalent_t, initializer_list<value_type> __il, const key_compare& __comp = key_compare())
       : flat_multiset(sorted_equivalent, __il.begin(), __il.end(), __comp) {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI explicit flat_multiset(const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 explicit flat_multiset(const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc)), __compare_() {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(const key_compare& __comp, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(const key_compare& __comp, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc)), __compare_(__comp) {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(const container_type& __keys, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(const container_type& __keys, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __keys)), __compare_() {
     ranges::sort(__keys_, __compare_);
   }
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __keys)), __compare_(__comp) {
     ranges::sort(__keys_, __compare_);
 @@ -206,14 +200,15 @@ public:
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(sorted_equivalent_t, const container_type& __keys, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(sorted_equivalent_t, const container_type& __keys, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __keys)), __compare_() {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted");
   }
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(sorted_equivalent_t, const container_type& __keys, const key_compare& __comp, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __keys)), __compare_(__comp) {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted");
 @@ -221,13 +216,14 @@ public:
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(const flat_multiset& __other, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(const flat_multiset& __other, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __other.__keys_)),
         __compare_(__other.__compare_) {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(flat_multiset&& __other, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(flat_multiset&& __other, const _Allocator& __alloc)
 #  if _LIBCPP_HAS_EXCEPTIONS
       try
 #  endif // _LIBCPP_HAS_EXCEPTIONS
 @@ -243,14 +239,15 @@ public:
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(_InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc)), __compare_() {
     insert(__first, __last);
   }
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(_InputIterator __first, _InputIterator __last, const key_compare& __comp, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc)), __compare_(__comp) {
     insert(__first, __last);
 @@ -258,7 +255,7 @@ public:
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(sorted_equivalent_t, _InputIterator __first, _InputIterator __last, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __first, __last)), __compare_() {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted");
 @@ -266,53 +263,57 @@ public:
   template <class _InputIterator, class _Allocator>
     requires(__has_input_iterator_category<_InputIterator>::value && uses_allocator<container_type, _Allocator>::value)
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(
-  flat_multiset(sorted_equivalent_t,
+      sorted_equivalent_t,
-                _InputIterator __first,
+      _InputIterator __first,
-                _InputIterator __last,
+      _InputIterator __last,
-                const key_compare& __comp,
+      const key_compare& __comp,
-                const _Allocator& __alloc)
+      const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc, __first, __last)), __compare_(__comp) {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys_, __compare_), "Key container is not sorted");
   }
   template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(from_range_t, _Range&& __rg, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(from_range_t, _Range&& __rg, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc)), __compare_() {
     insert_range(std::forward<_Range>(__rg));
   }
   template <_ContainerCompatibleRange<value_type> _Range, class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(from_range_t, _Range&& __rg, const key_compare& __comp, const _Allocator& __alloc)
       : __keys_(std::make_obj_using_allocator<container_type>(__alloc)), __compare_(__comp) {
     insert_range(std::forward<_Range>(__rg));
   }
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(initializer_list<value_type> __il, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(initializer_list<value_type> __il, const _Allocator& __alloc)
       : flat_multiset(__il.begin(), __il.end(), __alloc) {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
   flat_multiset(initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
       : flat_multiset(__il.begin(), __il.end(), __comp, __alloc) {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(sorted_equivalent_t, initializer_list<value_type> __il, const _Allocator& __alloc)
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26
+  flat_multiset(sorted_equivalent_t, initializer_list<value_type> __il, const _Allocator& __alloc)
       : flat_multiset(sorted_equivalent, __il.begin(), __il.end(), __alloc) {}
   template <class _Allocator>
     requires uses_allocator<container_type, _Allocator>::value
-  _LIBCPP_HIDE_FROM_ABI flat_multiset(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset(
       sorted_equivalent_t, initializer_list<value_type> __il, const key_compare& __comp, const _Allocator& __alloc)
       : flat_multiset(sorted_equivalent, __il.begin(), __il.end(), __comp, __alloc) {}
-  _LIBCPP_HIDE_FROM_ABI flat_multiset& operator=(initializer_list<value_type> __il) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset& operator=(initializer_list<value_type> __il) {
     clear();
     insert(__il);
     return *this;
 @@ -321,9 +322,9 @@ public:
   // copy/move assignment are not specified in the spec (defaulted)
   // but move assignment can potentially leave moved from object in an inconsistent
   // state if an exception is thrown
-  _LIBCPP_HIDE_FROM_ABI flat_multiset& operator=(const flat_multiset&) = default;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset& operator=(const flat_multiset&) = default;
-  _LIBCPP_HIDE_FROM_ABI flat_multiset& operator=(flat_multiset&& __other) noexcept(
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 flat_multiset& operator=(flat_multiset&& __other) noexcept(
       is_nothrow_move_assignable_v<_KeyContainer> && is_nothrow_move_assignable_v<_Compare>) {
     auto __clear_other_guard = std::__make_scope_guard([&]() noexcept { __other.clear() /* noexcept */; });
     auto __clear_self_guard  = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
 @@ -334,30 +335,60 @@ public:
   }
   // iterators
-  _LIBCPP_HIDE_FROM_ABI iterator begin() noexcept { return iterator(std::as_const(__keys_).begin()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator begin() noexcept {
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const noexcept { return const_iterator(__keys_.begin()); }
+    return iterator(std::as_const(__keys_).begin());
-  _LIBCPP_HIDE_FROM_ABI iterator end() noexcept { return iterator(std::as_const(__keys_).end()); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const noexcept { return const_iterator(__keys_.end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator begin() const noexcept {
+    return const_iterator(__keys_.begin());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator end() noexcept {
+    return iterator(std::as_const(__keys_).end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator end() const noexcept {
+    return const_iterator(__keys_.end());
+  }
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() noexcept { return reverse_iterator(end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rbegin() noexcept {
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const noexcept { return const_reverse_iterator(end()); }
+    return reverse_iterator(end());
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() noexcept { return reverse_iterator(begin()); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const noexcept { return const_reverse_iterator(begin()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rend() noexcept {
+    return reverse_iterator(begin());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const noexcept { return begin(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cbegin() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const noexcept { return end(); }
+    return begin();
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const noexcept { return const_reverse_iterator(end()); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const noexcept { return const_reverse_iterator(begin()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cend() const noexcept {
+    return end();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crbegin() const noexcept {
+    return const_reverse_iterator(end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crend() const noexcept {
+    return const_reverse_iterator(begin());
+  }
   // capacity
-  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool empty() const noexcept { return __keys_.empty(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool empty() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI size_type size() const noexcept { return __keys_.size(); }
+    return __keys_.empty();
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const noexcept { return __keys_.max_size(); }
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type size() const noexcept {
+    return __keys_.size();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type max_size() const noexcept {
+    return __keys_.max_size();
+  }
   // [flat.multiset.modifiers], modifiers
   template <class... _Args>
     requires is_constructible_v<value_type, _Args...>
-  _LIBCPP_HIDE_FROM_ABI iterator emplace(_Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator emplace(_Args&&... __args) {
     if constexpr (sizeof...(__args) == 1 && (is_same_v<remove_cvref_t<_Args>, _Key> && ...)) {
       return __emplace(std::forward<_Args>(__args)...);
     } else {
 @@ -367,7 +398,7 @@ public:
   template <class... _Args>
     requires is_constructible_v<value_type, _Args...>
-  _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator emplace_hint(const_iterator __hint, _Args&&... __args) {
     if constexpr (sizeof...(__args) == 1 && (is_same_v<remove_cvref_t<_Args>, _Key> && ...)) {
       return __emplace_hint(std::move(__hint), std::forward<_Args>(__args)...);
     } else {
 @@ -375,21 +406,23 @@ public:
     }
   }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return emplace(__x); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const value_type& __x) { return emplace(__x); }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(value_type&& __x) { return emplace(std::move(__x)); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(value_type&& __x) {
+    return emplace(std::move(__x));
+  }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, const value_type& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const_iterator __hint, const value_type& __x) {
     return emplace_hint(__hint, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __hint, value_type&& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator insert(const_iterator __hint, value_type&& __x) {
     return emplace_hint(__hint, std::move(__x));
   }
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert(_InputIterator __first, _InputIterator __last) {
     if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
       __reserve(__last - __first);
     }
 @@ -398,7 +431,8 @@ public:
   template <class _InputIterator>
     requires __has_input_iterator_category<_InputIterator>::value
-  _LIBCPP_HIDE_FROM_ABI void insert(sorted_equivalent_t, _InputIterator __first, _InputIterator __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  insert(sorted_equivalent_t, _InputIterator __first, _InputIterator __last) {
     if constexpr (sized_sentinel_for<_InputIterator, _InputIterator>) {
       __reserve(__last - __first);
     }
 @@ -407,7 +441,7 @@ public:
   }
   template <_ContainerCompatibleRange<value_type> _Range>
-  _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert_range(_Range&& __range) {
     if constexpr (ranges::sized_range<_Range>) {
       __reserve(ranges::size(__range));
     }
 @@ -415,26 +449,38 @@ public:
     __append_sort_merge</*WasSorted = */ false>(std::forward<_Range>(__range));
   }
-  _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert_range(sorted_equivalent_t, _Range&& __range) {
+    if constexpr (ranges::sized_range<_Range>) {
+      __reserve(ranges::size(__range));
+    }
-  _LIBCPP_HIDE_FROM_ABI void insert(sorted_equivalent_t, initializer_list<value_type> __il) {
+    __append_sort_merge</*WasSorted = */ true>(std::forward<_Range>(__range));
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert(initializer_list<value_type> __il) {
+    insert(__il.begin(), __il.end());
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  insert(sorted_equivalent_t, initializer_list<value_type> __il) {
     insert(sorted_equivalent, __il.begin(), __il.end());
   }
-  _LIBCPP_HIDE_FROM_ABI container_type extract() && {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 container_type extract() && {
     auto __guard = std::__make_scope_guard([&]() noexcept { clear() /* noexcept */; });
     auto __ret   = std::move(__keys_);
     return __ret;
   }
-  _LIBCPP_HIDE_FROM_ABI void replace(container_type&& __keys) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void replace(container_type&& __keys) {
     _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(ranges::is_sorted(__keys, __compare_), "Key container is not sorted");
     auto __guard = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     __keys_      = std::move(__keys);
     __guard.__complete();
   }
-  _LIBCPP_HIDE_FROM_ABI iterator erase(iterator __position) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator erase(iterator __position) {
     auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     auto __key_iter   = __keys_.erase(__position.__base());
     __on_failure.__complete();
 @@ -444,7 +490,7 @@ public:
   // The following overload is the same as the iterator overload
   // iterator erase(const_iterator __position);
-  _LIBCPP_HIDE_FROM_ABI size_type erase(const key_type& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type erase(const key_type& __x) {
     auto [__first, __last] = equal_range(__x);
     auto __res             = __last - __first;
     erase(__first, __last);
 @@ -454,149 +500,170 @@ public:
   template <class _Kp>
     requires(__is_transparent_v<_Compare> && !is_convertible_v<_Kp &&, iterator> &&
              !is_convertible_v<_Kp &&, const_iterator>)
-  _LIBCPP_HIDE_FROM_ABI size_type erase(_Kp&& __x) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type erase(_Kp&& __x) {
     auto [__first, __last] = equal_range(__x);
     auto __res             = __last - __first;
     erase(__first, __last);
     return __res;
   }
-  _LIBCPP_HIDE_FROM_ABI iterator erase(const_iterator __first, const_iterator __last) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator erase(const_iterator __first, const_iterator __last) {
     auto __on_failure = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     auto __key_it     = __keys_.erase(__first.__base(), __last.__base());
     __on_failure.__complete();
     return iterator(std::move(__key_it));
   }
-  _LIBCPP_HIDE_FROM_ABI void swap(flat_multiset& __y) noexcept {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
-    // warning: The spec has unconditional noexcept, which means that
+  swap(flat_multiset& __y) noexcept(is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>) {
-    // if any of the following functions throw an exception,
+    auto __on_failure = std::__make_exception_guard([&]() noexcept {
-    // std::terminate will be called
+      clear() /* noexcept */;
-    // This is discussed in P3567, which hasn't been voted on yet.
+      __y.clear() /* noexcept */;
+    });
     ranges::swap(__compare_, __y.__compare_);
     ranges::swap(__keys_, __y.__keys_);
+    __on_failure.__complete();
   }
-  _LIBCPP_HIDE_FROM_ABI void clear() noexcept { __keys_.clear(); }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void clear() noexcept { __keys_.clear(); }
   // observers
-  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __compare_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 key_compare key_comp() const { return __compare_; }
-  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __compare_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare value_comp() const {
+    return __compare_;
+  }
   // map operations
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __x) { return __find_impl(*this, __x); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const key_type& __x) {
+    return __find_impl(*this, __x);
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __x) const { return __find_impl(*this, __x); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const key_type& __x) const {
+    return __find_impl(*this, __x);
+  }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const _Kp& __x) {
     return __find_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const _Kp& __x) const {
     return __find_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const key_type& __x) const {
     auto [__first, __last] = equal_range(__x);
     return __last - __first;
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const _Kp& __x) const {
     auto [__first, __last] = equal_range(__x);
     return __last - __first;
   }
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __x) const { return find(__x) != end(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const key_type& __x) const {
+    return find(__x) != end();
+  }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const _Kp& __x) const {
     return find(__x) != end();
   }
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const key_type& __x) {
     const auto& __keys = __keys_;
     return iterator(std::lower_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  lower_bound(const key_type& __x) const {
     return const_iterator(std::lower_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const _Kp& __x) {
     const auto& __keys = __keys_;
     return iterator(std::lower_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const _Kp& __x) const {
     return const_iterator(std::lower_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const key_type& __x) {
     const auto& __keys = __keys_;
     return iterator(std::upper_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  upper_bound(const key_type& __x) const {
     return const_iterator(std::upper_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const _Kp& __x) {
     const auto& __keys = __keys_;
     return iterator(std::upper_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const _Kp& __x) const {
     return const_iterator(std::upper_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const key_type& __x) {
     return __equal_range_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  equal_range(const key_type& __x) const {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const _Kp& __x) {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  equal_range(const _Kp& __x) const {
     return __equal_range_impl(*this, __x);
   }
-  friend _LIBCPP_HIDE_FROM_ABI bool operator==(const flat_multiset& __x, const flat_multiset& __y) {
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool
+  operator==(const flat_multiset& __x, const flat_multiset& __y) {
     return ranges::equal(__x, __y);
   }
-  friend _LIBCPP_HIDE_FROM_ABI auto operator<=>(const flat_multiset& __x, const flat_multiset& __y) {
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 auto
+  operator<=>(const flat_multiset& __x, const flat_multiset& __y) {
     return std::lexicographical_compare_three_way(
         __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
   }
-  friend _LIBCPP_HIDE_FROM_ABI void swap(flat_multiset& __x, flat_multiset& __y) noexcept { __x.swap(__y); }
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  swap(flat_multiset& __x, flat_multiset& __y) noexcept(noexcept(__x.swap(__y))) {
+    __x.swap(__y);
+  }
 private:
   template <bool _WasSorted, class... _Args>
-  _LIBCPP_HIDE_FROM_ABI void __append_sort_merge(_Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void __append_sort_merge(_Args&&... __args) {
     auto __on_failure    = std::__make_exception_guard([&]() noexcept { clear() /* noexcept */; });
     size_type __old_size = size();
     __flat_set_utils::__append(*this, std::forward<_Args>(__args)...);
 @@ -604,20 +671,20 @@ private:
       ranges::sort(__keys_.begin() + __old_size, __keys_.end(), __compare_);
     } else {
       _LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(
-          ranges::is_sorted(__keys_ | ranges::views::drop(__old_size)), "Key container is not sorted");
+          ranges::is_sorted(__keys_ | ranges::views::drop(__old_size), __compare_), "Key container is not sorted");
     }
     ranges::inplace_merge(__keys_.begin(), __keys_.begin() + __old_size, __keys_.end(), __compare_);
     __on_failure.__complete();
   }
   template <class _Kp>
-  _LIBCPP_HIDE_FROM_ABI iterator __emplace(_Kp&& __key) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator __emplace(_Kp&& __key) {
     auto __it = upper_bound(__key);
     return __flat_set_utils::__emplace_exact_pos(*this, __it, std::forward<_Kp>(__key));
   }
   template <class _Kp>
-  _LIBCPP_HIDE_FROM_ABI iterator __emplace_hint(const_iterator __hint, _Kp&& __key) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator __emplace_hint(const_iterator __hint, _Kp&& __key) {
     auto __prev_larger  = __hint != cbegin() && __compare_(__key, *std::prev(__hint));
     auto __next_smaller = __hint != cend() && __compare_(*__hint, __key);
 @@ -649,7 +716,7 @@ private:
   }
   template <class _Self, class _Kp>
-  _LIBCPP_HIDE_FROM_ABI static auto __find_impl(_Self&& __self, const _Kp& __key) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static auto __find_impl(_Self&& __self, const _Kp& __key) {
     auto __it   = __self.lower_bound(__key);
     auto __last = __self.end();
     if (__it == __last || __self.__compare_(__key, *__it)) {
 @@ -659,29 +726,30 @@ private:
   }
   template <class _Self, class _Kp>
-  _LIBCPP_HIDE_FROM_ABI static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 static auto __equal_range_impl(_Self&& __self, const _Kp& __key) {
     using __iter = _If<is_const_v<__libcpp_remove_reference_t<_Self>>, const_iterator, iterator>;
     auto [__key_first, __key_last] =
         std::equal_range(__self.__keys_.begin(), __self.__keys_.end(), __key, __self.__compare_);
     return std::make_pair(__iter(__key_first), __iter(__key_last));
   }
-  _LIBCPP_HIDE_FROM_ABI void __reserve(size_t __size) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void __reserve(size_t __size) {
     if constexpr (__container_traits<_KeyContainer>::__reservable) {
       __keys_.reserve(__size);
     }
   }
   template <class _Key2, class _Compare2, class _KeyContainer2, class _Predicate>
-  friend typename flat_multiset<_Key2, _Compare2, _KeyContainer2>::size_type
+  friend typename flat_multiset<_Key2, _Compare2, _KeyContainer2>::size_type _LIBCPP_CONSTEXPR_SINCE_CXX26
   erase_if(flat_multiset<_Key2, _Compare2, _KeyContainer2>&, _Predicate);
   _KeyContainer __keys_;
   _LIBCPP_NO_UNIQUE_ADDRESS key_compare __compare_;
   struct __key_equiv {
-    _LIBCPP_HIDE_FROM_ABI __key_equiv(key_compare __c) : __comp_(__c) {}
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 __key_equiv(key_compare __c) : __comp_(__c) {}
-    _LIBCPP_HIDE_FROM_ABI bool operator()(const_reference __x, const_reference __y) const {
+    _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool
+    operator()(const_reference __x, const_reference __y) const {
       return !__comp_(std::get<0>(__x), std::get<0>(__y)) && !__comp_(std::get<0>(__y), std::get<0>(__x));
     }
     key_compare __comp_;
 @@ -689,7 +757,7 @@ private:
 };
 template <class _KeyContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -697,12 +765,12 @@ flat_multiset(_KeyContainer, _Compare = _Compare())
     -> flat_multiset<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
 template <class _KeyContainer, class _Allocator>
-  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value)
+  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator_v<_KeyContainer>)
 flat_multiset(_KeyContainer, _Allocator)
     -> flat_multiset<typename _KeyContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer>;
 template <class _KeyContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            uses_allocator_v<_KeyContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
 @@ -711,7 +779,7 @@ flat_multiset(_KeyContainer, _Compare, _Allocator)
     -> flat_multiset<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
 template <class _KeyContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -719,12 +787,12 @@ flat_multiset(sorted_equivalent_t, _KeyContainer, _Compare = _Compare())
     -> flat_multiset<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
 template <class _KeyContainer, class _Allocator>
-  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value)
+  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator_v<_KeyContainer>)
 flat_multiset(sorted_equivalent_t, _KeyContainer, _Allocator)
     -> flat_multiset<typename _KeyContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer>;
 template <class _KeyContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            uses_allocator_v<_KeyContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
 @@ -732,37 +800,37 @@ template <class _KeyContainer, class _Compare, class _Allocator>
 flat_multiset(sorted_equivalent_t, _KeyContainer, _Compare, _Allocator)
     -> flat_multiset<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
-template <class _InputIterator, class _Compare = less<__iter_value_type<_InputIterator>>>
+template <class _InputIterator, class _Compare = less<__iterator_value_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_multiset(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_multiset<__iter_value_type<_InputIterator>, _Compare>;
+    -> flat_multiset<__iterator_value_type<_InputIterator>, _Compare>;
-template <class _InputIterator, class _Compare = less<__iter_value_type<_InputIterator>>>
+template <class _InputIterator, class _Compare = less<__iterator_value_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_multiset(sorted_equivalent_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_multiset<__iter_value_type<_InputIterator>, _Compare>;
+    -> flat_multiset<__iterator_value_type<_InputIterator>, _Compare>;
 template <ranges::input_range _Range,
           class _Compare   = less<ranges::range_value_t<_Range>>,
           class _Allocator = allocator<ranges::range_value_t<_Range>>,
-          class            = __enable_if_t<!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value>>
+          class            = __enable_if_t<!__is_allocator_v<_Compare> && __is_allocator_v<_Allocator>>>
 flat_multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_multiset<
     ranges::range_value_t<_Range>,
     _Compare,
     vector<ranges::range_value_t<_Range>, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>;
-template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator_v<_Allocator>>>
 flat_multiset(from_range_t, _Range&&, _Allocator) -> flat_multiset<
     ranges::range_value_t<_Range>,
     less<ranges::range_value_t<_Range>>,
     vector<ranges::range_value_t<_Range>, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>;
 template <class _Key, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_multiset(initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>;
 template <class _Key, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_multiset(sorted_equivalent_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_multiset<_Key, _Compare>;
 template <class _Key, class _Compare, class _KeyContainer, class _Allocator>
 @@ -770,7 +838,7 @@ struct uses_allocator<flat_multiset<_Key, _Compare, _KeyContainer>, _Allocator>
     : bool_constant<uses_allocator_v<_KeyContainer, _Allocator> > {};
 template <class _Key, class _Compare, class _KeyContainer, class _Predicate>
-_LIBCPP_HIDE_FROM_ABI typename flat_multiset<_Key, _Compare, _KeyContainer>::size_type
+_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 typename flat_multiset<_Key, _Compare, _KeyContainer>::size_type
 erase_if(flat_multiset<_Key, _Compare, _KeyContainer>& __flat_multiset, _Predicate __pred) {
   auto __guard = std::__make_exception_guard([&] { __flat_multiset.clear(); });
   auto __it =

lib/libcxx/include/__flat_set/flat_set.h+86-68

 @@ -12,7 +12,6 @@
 #include <__algorithm/lexicographical_compare_three_way.h>
 #include <__algorithm/lower_bound.h>
-#include <__algorithm/min.h>
 #include <__algorithm/ranges_adjacent_find.h>
 #include <__algorithm/ranges_equal.h>
 #include <__algorithm/ranges_inplace_merge.h>
 @@ -24,20 +23,16 @@
 #include <__compare/synth_three_way.h>
 #include <__concepts/swappable.h>
 #include <__config>
-#include <__cstddef/ptrdiff_t.h>
 #include <__flat_map/sorted_unique.h>
 #include <__flat_set/ra_iterator.h>
 #include <__flat_set/utils.h>
-#include <__functional/invoke.h>
 #include <__functional/is_transparent.h>
 #include <__functional/operations.h>
 #include <__fwd/vector.h>
 #include <__iterator/concepts.h>
-#include <__iterator/distance.h>
 #include <__iterator/iterator_traits.h>
 #include <__iterator/next.h>
 #include <__iterator/prev.h>
-#include <__iterator/ranges_iterator_traits.h>
 #include <__iterator/reverse_iterator.h>
 #include <__memory/allocator_traits.h>
 #include <__memory/uses_allocator.h>
 @@ -47,10 +42,7 @@
 #include <__ranges/container_compatible_range.h>
 #include <__ranges/drop_view.h>
 #include <__ranges/from_range.h>
-#include <__ranges/ref_view.h>
 #include <__ranges/size.h>
-#include <__ranges/subrange.h>
-#include <__type_traits/conjunction.h>
 #include <__type_traits/container_traits.h>
 #include <__type_traits/invoke.h>
 #include <__type_traits/is_allocator.h>
 @@ -347,38 +339,42 @@ public:
   }
   // iterators
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator begin() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator begin() noexcept {
     return iterator(std::as_const(__keys_).begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator begin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator begin() const noexcept {
     return const_iterator(__keys_.begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator end() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator end() noexcept {
     return iterator(std::as_const(__keys_).end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator end() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator end() const noexcept {
     return const_iterator(__keys_.end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rbegin() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rbegin() noexcept {
     return reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rbegin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rbegin() const noexcept {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rend() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 reverse_iterator rend() noexcept {
     return reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rend() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator rend() const noexcept {
     return const_reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cbegin() const noexcept { return begin(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cbegin() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cend() const noexcept { return end(); }
+    return begin();
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crbegin() const noexcept {
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator cend() const noexcept {
+    return end();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crbegin() const noexcept {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crend() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_reverse_iterator crend() const noexcept {
     return const_reverse_iterator(begin());
   }
 @@ -387,9 +383,13 @@ public:
     return __keys_.empty();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type size() const noexcept { return __keys_.size(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type size() const noexcept {
+    return __keys_.size();
+  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type max_size() const noexcept { return __keys_.max_size(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type max_size() const noexcept {
+    return __keys_.max_size();
+  }
   // [flat.set.modifiers], modifiers
   template <class... _Args>
 @@ -466,6 +466,15 @@ public:
     __append_sort_merge_unique</*WasSorted = */ false>(std::forward<_Range>(__range));
   }
+  template <_ContainerCompatibleRange<value_type> _Range>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert_range(std::sorted_unique_t, _Range&& __range) {
+    if constexpr (ranges::sized_range<_Range>) {
+      __reserve(ranges::size(__range));
+    }
+    __append_sort_merge_unique</*WasSorted = */ true>(std::forward<_Range>(__range));
+  }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void insert(initializer_list<value_type> __il) {
     insert(__il.begin(), __il.end());
   }
 @@ -474,7 +483,7 @@ public:
     insert(sorted_unique, __il.begin(), __il.end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 container_type extract() && {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 container_type extract() && {
     auto __guard = std::__make_scope_guard([&]() noexcept { clear() /* noexcept */; });
     auto __ret   = std::move(__keys_);
     return __ret;
 @@ -524,123 +533,131 @@ public:
     return iterator(std::move(__key_it));
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void swap(flat_set& __y) noexcept {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
-    // warning: The spec has unconditional noexcept, which means that
+  swap(flat_set& __y) noexcept(is_nothrow_swappable_v<container_type> && is_nothrow_swappable_v<key_compare>) {
-    // if any of the following functions throw an exception,
+    auto __on_failure = std::__make_exception_guard([&]() noexcept {
-    // std::terminate will be called.
+      clear() /* noexcept */;
-    // This is discussed in P2767, which hasn't been voted on yet.
+      __y.clear() /* noexcept */;
+    });
     ranges::swap(__compare_, __y.__compare_);
     ranges::swap(__keys_, __y.__keys_);
+    __on_failure.__complete();
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void clear() noexcept { __keys_.clear(); }
   // observers
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 key_compare key_comp() const { return __compare_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 key_compare key_comp() const { return __compare_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare value_comp() const { return __compare_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 value_compare value_comp() const {
+    return __compare_;
+  }
   // set operations
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const key_type& __x) {
     return __find_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const key_type& __x) const {
     return __find_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator find(const _Kp& __x) {
     return __find_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator find(const _Kp& __x) const {
     return __find_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const key_type& __x) const {
     return contains(__x) ? 1 : 0;
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 size_type count(const _Kp& __x) const {
     return contains(__x) ? 1 : 0;
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const key_type& __x) const {
     return find(__x) != end();
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool contains(const _Kp& __x) const {
     return find(__x) != end();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const key_type& __x) {
     const auto& __keys = __keys_;
     return iterator(std::lower_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  lower_bound(const key_type& __x) const {
     return const_iterator(std::lower_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator lower_bound(const _Kp& __x) {
     const auto& __keys = __keys_;
     return iterator(std::lower_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator lower_bound(const _Kp& __x) const {
     return const_iterator(std::lower_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const key_type& __x) {
     const auto& __keys = __keys_;
     return iterator(std::upper_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const key_type& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator
+  upper_bound(const key_type& __x) const {
     return const_iterator(std::upper_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 iterator upper_bound(const _Kp& __x) {
     const auto& __keys = __keys_;
     return iterator(std::upper_bound(__keys.begin(), __keys.end(), __x, __compare_));
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const _Kp& __x) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 const_iterator upper_bound(const _Kp& __x) const {
     return const_iterator(std::upper_bound(__keys_.begin(), __keys_.end(), __x, __compare_));
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator> equal_range(const key_type& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const key_type& __x) {
     return __equal_range_impl(*this, __x);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
   equal_range(const key_type& __x) const {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator> equal_range(const _Kp& __x) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<iterator, iterator>
+  equal_range(const _Kp& __x) {
     return __equal_range_impl(*this, __x);
   }
   template <class _Kp>
     requires __is_transparent_v<_Compare>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 pair<const_iterator, const_iterator>
   equal_range(const _Kp& __x) const {
     return __equal_range_impl(*this, __x);
   }
 @@ -655,13 +672,14 @@ public:
         __x.begin(), __x.end(), __y.begin(), __y.end(), std::__synth_three_way);
   }
-  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void swap(flat_set& __x, flat_set& __y) noexcept {
+  friend _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 void
+  swap(flat_set& __x, flat_set& __y) noexcept(noexcept(__x.swap(__y))) {
     __x.swap(__y);
   }
 private:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX26 bool __is_sorted_and_unique(auto&& __key_container) const {
-    auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) { return !__compare_(__x, __y); };
+    auto __greater_or_equal_to = [this](const auto& __x, const auto& __y) -> bool { return !__compare_(__x, __y); };
     return ranges::adjacent_find(__key_container, __greater_or_equal_to) == ranges::end(__key_container);
   }
 @@ -774,19 +792,19 @@ private:
 };
 template <class _KeyContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 flat_set(_KeyContainer, _Compare = _Compare()) -> flat_set<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
 template <class _KeyContainer, class _Allocator>
-  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value)
+  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator_v<_KeyContainer>)
 flat_set(_KeyContainer, _Allocator)
     -> flat_set<typename _KeyContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer>;
 template <class _KeyContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            uses_allocator_v<_KeyContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
 @@ -794,7 +812,7 @@ template <class _KeyContainer, class _Compare, class _Allocator>
 flat_set(_KeyContainer, _Compare, _Allocator) -> flat_set<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
 template <class _KeyContainer, class _Compare = less<typename _KeyContainer::value_type>>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
                           const typename _KeyContainer::value_type&>)
 @@ -802,12 +820,12 @@ flat_set(sorted_unique_t, _KeyContainer, _Compare = _Compare())
     -> flat_set<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
 template <class _KeyContainer, class _Allocator>
-  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator<_KeyContainer>::value)
+  requires(uses_allocator_v<_KeyContainer, _Allocator> && !__is_allocator_v<_KeyContainer>)
 flat_set(sorted_unique_t, _KeyContainer, _Allocator)
     -> flat_set<typename _KeyContainer::value_type, less<typename _KeyContainer::value_type>, _KeyContainer>;
 template <class _KeyContainer, class _Compare, class _Allocator>
-  requires(!__is_allocator<_Compare>::value && !__is_allocator<_KeyContainer>::value &&
+  requires(!__is_allocator_v<_Compare> && !__is_allocator_v<_KeyContainer> &&
            uses_allocator_v<_KeyContainer, _Allocator> &&
            is_invocable_v<const _Compare&,
                           const typename _KeyContainer::value_type&,
 @@ -815,37 +833,37 @@ template <class _KeyContainer, class _Compare, class _Allocator>
 flat_set(sorted_unique_t, _KeyContainer, _Compare, _Allocator)
     -> flat_set<typename _KeyContainer::value_type, _Compare, _KeyContainer>;
-template <class _InputIterator, class _Compare = less<__iter_value_type<_InputIterator>>>
+template <class _InputIterator, class _Compare = less<__iterator_value_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_set(_InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_set<__iter_value_type<_InputIterator>, _Compare>;
+    -> flat_set<__iterator_value_type<_InputIterator>, _Compare>;
-template <class _InputIterator, class _Compare = less<__iter_value_type<_InputIterator>>>
+template <class _InputIterator, class _Compare = less<__iterator_value_type<_InputIterator>>>
-  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator<_Compare>::value)
+  requires(__has_input_iterator_category<_InputIterator>::value && !__is_allocator_v<_Compare>)
 flat_set(sorted_unique_t, _InputIterator, _InputIterator, _Compare = _Compare())
-    -> flat_set<__iter_value_type<_InputIterator>, _Compare>;
+    -> flat_set<__iterator_value_type<_InputIterator>, _Compare>;
 template <ranges::input_range _Range,
           class _Compare   = less<ranges::range_value_t<_Range>>,
           class _Allocator = allocator<ranges::range_value_t<_Range>>,
-          class            = __enable_if_t<!__is_allocator<_Compare>::value && __is_allocator<_Allocator>::value>>
+          class            = __enable_if_t<!__is_allocator_v<_Compare> && __is_allocator_v<_Allocator>>>
 flat_set(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator()) -> flat_set<
     ranges::range_value_t<_Range>,
     _Compare,
     vector<ranges::range_value_t<_Range>, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>;
-template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = __enable_if_t<__is_allocator_v<_Allocator>>>
 flat_set(from_range_t, _Range&&, _Allocator) -> flat_set<
     ranges::range_value_t<_Range>,
     less<ranges::range_value_t<_Range>>,
     vector<ranges::range_value_t<_Range>, __allocator_traits_rebind_t<_Allocator, ranges::range_value_t<_Range>>>>;
 template <class _Key, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_set(initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>;
 template <class _Key, class _Compare = less<_Key>>
-  requires(!__is_allocator<_Compare>::value)
+  requires(!__is_allocator_v<_Compare>)
 flat_set(sorted_unique_t, initializer_list<_Key>, _Compare = _Compare()) -> flat_set<_Key, _Compare>;
 template <class _Key, class _Compare, class _KeyContainer, class _Allocator>

lib/libcxx/include/__format/concepts.h-14

...	@@ -15,12 +15,8 @@	...	@@ -15,12 +15,8 @@
15	#include <__config>	15	#include <__config>
16	#include <__format/format_parse_context.h>	16	#include <__format/format_parse_context.h>
17	#include <__fwd/format.h>	17	#include <__fwd/format.h>
18	#include <__fwd/tuple.h>
19	#include <__tuple/tuple_size.h>
20	#include <__type_traits/is_specialization.h>
21	#include <__type_traits/remove_const.h>	18	#include <__type_traits/remove_const.h>
22	#include <__type_traits/remove_reference.h>	19	#include <__type_traits/remove_reference.h>
23	#include <__utility/pair.h>
24		20
25	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
26	# pragma GCC system_header	22	# pragma GCC system_header
...	@@ -65,16 +61,6 @@ concept __formattable =	...	@@ -65,16 +61,6 @@ concept __formattable =
65	# if _LIBCPP_STD_VER >= 23	61	# if _LIBCPP_STD_VER >= 23
66	template <class _Tp, class _CharT>	62	template <class _Tp, class _CharT>
67	concept formattable = __formattable<_Tp, _CharT>;	63	concept formattable = __formattable<_Tp, _CharT>;
68
69	// [tuple.like] defines a tuple-like exposition only concept. This concept is
70	// not related to that. Therefore it uses a different name for the concept.
71	//
72	// TODO FMT Add a test to validate we fail when using that concept after P2165
73	// has been implemented.
74	template <class _Tp>
75	concept __fmt_pair_like =
76	__is_specialization_v<_Tp, pair> \|\| (__is_specialization_v<_Tp, tuple> && tuple_size_v<_Tp> == 2);
77
78	# endif // _LIBCPP_STD_VER >= 23	64	# endif // _LIBCPP_STD_VER >= 23
79	#endif // _LIBCPP_STD_VER >= 20	65	#endif // _LIBCPP_STD_VER >= 20
80		66

lib/libcxx/include/__format/extended_grapheme_cluster_table.h+3-2

...	@@ -61,7 +61,7 @@	...	@@ -61,7 +61,7 @@
61	#ifndef _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H	61	#ifndef _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H
62	#define _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H	62	#define _LIBCPP___FORMAT_EXTENDED_GRAPHEME_CLUSTER_TABLE_H
63		63
64	#include <__algorithm/ranges_upper_bound.h>	64	#include <__algorithm/upper_bound.h>
65	#include <__config>	65	#include <__config>
66	#include <__cstddef/ptrdiff_t.h>	66	#include <__cstddef/ptrdiff_t.h>
67	#include <__iterator/access.h>	67	#include <__iterator/access.h>
...	@@ -1647,7 +1647,8 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[1501] = {	...	@@ -1647,7 +1647,8 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[1501] = {
1647	// size. Then the upper bound for code point 3 will return the entry after	1647	// size. Then the upper bound for code point 3 will return the entry after
1648	// 0x1810. After moving to the previous entry the algorithm arrives at the	1648	// 0x1810. After moving to the previous entry the algorithm arrives at the
1649	// correct entry.	1649	// correct entry.
1650	ptrdiff_t __i = std::ranges::upper_bound(__entries, (__code_point << 11) \| 0x7ffu) - __entries;	1650	ptrdiff_t __i =
		1651	std::upper_bound(std::begin(__entries), std::end(__entries), (__code_point << 11) \| 0x7ffu) - __entries;
1651	if (__i == 0)	1652	if (__i == 0)
1652	return __property::__none;	1653	return __property::__none;
1653		1654

lib/libcxx/include/__format/fmt_pair_like.h created+42

...	@@ -0,0 +1,42 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___FORMAT_FMT_PAIR_LIKE_H
11	#define _LIBCPP___FORMAT_FMT_PAIR_LIKE_H
12
13	#include <__config>
14	#include <__fwd/pair.h>
15	#include <__fwd/tuple.h>
16	#include <__tuple/tuple_size.h>
17	#include <__type_traits/is_specialization.h>
18
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header
21	#endif
22
23	_LIBCPP_BEGIN_NAMESPACE_STD
24
25	#if _LIBCPP_STD_VER >= 23
26
27	// [tuple.like] defines a tuple-like exposition only concept. This concept is not related to that. Therefore it uses a
28	// different name for the concept.
29	//
30	// TODO FMT Add a test to validate we fail when using that concept after P2165 has been implemented.
31
32	// [format.range.fmtkind]/2.2.1 and [tab:formatter.range.type]:
33	// "U is either a specialization of pair or a specialization of tuple such that tuple_size_v<U> is 2."
34	template <class _Tp>
35	concept __fmt_pair_like =
36	__is_specialization_v<_Tp, pair> \|\| (__is_specialization_v<_Tp, tuple> && tuple_size_v<_Tp> == 2);
37
38	#endif // _LIBCPP_STD_VER >= 23
39
40	_LIBCPP_END_NAMESPACE_STD
41
42	#endif // _LIBCPP___FORMAT_FMT_PAIR_LIKE_H

lib/libcxx/include/__format/format_arg.h+7-10

...	@@ -149,7 +149,7 @@ _LIBCPP_HIDE_FROM_ABI decltype(auto) __visit_format_arg(_Visitor&& __vis, basic_	...	@@ -149,7 +149,7 @@ _LIBCPP_HIDE_FROM_ABI decltype(auto) __visit_format_arg(_Visitor&& __vis, basic_
149	__libcpp_unreachable();	149	__libcpp_unreachable();
150	}	150	}
151		151
152	# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	152	# if _LIBCPP_STD_VER >= 26
153		153
154	template <class _Rp, class _Visitor, class _Context>	154	template <class _Rp, class _Visitor, class _Context>
155	_LIBCPP_HIDE_FROM_ABI _Rp __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {	155	_LIBCPP_HIDE_FROM_ABI _Rp __visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
...	@@ -200,7 +200,7 @@ _LIBCPP_HIDE_FROM_ABI _Rp __visit_format_arg(_Visitor&& __vis, basic_format_arg<	...	@@ -200,7 +200,7 @@ _LIBCPP_HIDE_FROM_ABI _Rp __visit_format_arg(_Visitor&& __vis, basic_format_arg<
200	__libcpp_unreachable();	200	__libcpp_unreachable();
201	}	201	}
202		202
203	# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	203	# endif // _LIBCPP_STD_VER >= 26
204		204
205	/// Contains the values used in basic_format_arg.	205	/// Contains the values used in basic_format_arg.
206	///	206	///
...	@@ -285,7 +285,7 @@ public:	...	@@ -285,7 +285,7 @@ public:
285		285
286	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { return __type_ != __format::__arg_t::__none; }	286	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const noexcept { return __type_ != __format::__arg_t::__none; }
287		287
288	# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	288	# if _LIBCPP_STD_VER >= 26
289		289
290	// This function is user facing, so it must wrap the non-standard types of	290	// This function is user facing, so it must wrap the non-standard types of
291	// the "variant" in a handle to stay conforming. See __arg_t for more details.	291	// the "variant" in a handle to stay conforming. See __arg_t for more details.
...	@@ -329,7 +329,7 @@ public:	...	@@ -329,7 +329,7 @@ public:
329	}	329	}
330	}	330	}
331		331
332	# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	332	# endif // _LIBCPP_STD_VER >= 26
333		333
334	private:	334	private:
335	using char_type = typename _Context::char_type;	335	using char_type = typename _Context::char_type;
...	@@ -371,11 +371,8 @@ private:	...	@@ -371,11 +371,8 @@ private:
371	// This function is user facing, so it must wrap the non-standard types of	371	// This function is user facing, so it must wrap the non-standard types of
372	// the "variant" in a handle to stay conforming. See __arg_t for more details.	372	// the "variant" in a handle to stay conforming. See __arg_t for more details.
373	template <class _Visitor, class _Context>	373	template <class _Visitor, class _Context>
374	# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	374	_LIBCPP_DEPRECATED_IN_CXX26 _LIBCPP_HIDE_FROM_ABI decltype(auto)
375	_LIBCPP_DEPRECATED_IN_CXX26	375	visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
376	# endif
377	_LIBCPP_HIDE_FROM_ABI decltype(auto)
378	visit_format_arg(_Visitor&& __vis, basic_format_arg<_Context> __arg) {
379	switch (__arg.__type_) {	376	switch (__arg.__type_) {
380	# if _LIBCPP_HAS_INT128	377	# if _LIBCPP_HAS_INT128
381	case __format::__arg_t::__i128: {	378	case __format::__arg_t::__i128: {
...	@@ -387,7 +384,7 @@ _LIBCPP_DEPRECATED_IN_CXX26	...	@@ -387,7 +384,7 @@ _LIBCPP_DEPRECATED_IN_CXX26
387	typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};	384	typename __basic_format_arg_value<_Context>::__handle __h{__arg.__value_.__u128_};
388	return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});	385	return std::invoke(std::forward<_Visitor>(__vis), typename basic_format_arg<_Context>::handle{__h});
389	}	386	}
390	# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	387	# endif // _LIBCPP_HAS_INT128
391	default:	388	default:
392	return std::__visit_format_arg(std::forward<_Visitor>(__vis), __arg);	389	return std::__visit_format_arg(std::forward<_Visitor>(__vis), __arg);
393	}	390	}

lib/libcxx/include/__format/format_args.h+1-1

...	@@ -40,7 +40,7 @@ public:	...	@@ -40,7 +40,7 @@ public:
40	}	40	}
41	}	41	}
42		42
43	_LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> get(size_t __id) const noexcept {	43	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_format_arg<_Context> get(size_t __id) const noexcept {
44	if (__id >= __size_)	44	if (__id >= __size_)
45	return basic_format_arg<_Context>{};	45	return basic_format_arg<_Context>{};
46		46

lib/libcxx/include/__format/format_context.h+5-5

...	@@ -80,17 +80,17 @@ public:	...	@@ -80,17 +80,17 @@ public:
80	template <class _Tp>	80	template <class _Tp>
81	using formatter_type = formatter<_Tp, _CharT>;	81	using formatter_type = formatter<_Tp, _CharT>;
82		82
83	_LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context> arg(size_t __id) const noexcept {	83	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_format_arg<basic_format_context> arg(size_t __id) const noexcept {
84	return __args_.get(__id);	84	return __args_.get(__id);
85	}	85	}
86	# if _LIBCPP_HAS_LOCALIZATION	86	# if _LIBCPP_HAS_LOCALIZATION
87	_LIBCPP_HIDE_FROM_ABI std::locale locale() {	87	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI std::locale locale() {
88	if (!__loc_)	88	if (!__loc_)
89	__loc_ = std::locale{};	89	__loc_ = std::locale{};
90	return *__loc_;	90	return *__loc_;
91	}	91	}
92	# endif	92	# endif
93	_LIBCPP_HIDE_FROM_ABI iterator out() { return std::move(__out_it_); }	93	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI iterator out() { return std::move(__out_it_); }
94	_LIBCPP_HIDE_FROM_ABI void advance_to(iterator __it) { __out_it_ = std::move(__it); }	94	_LIBCPP_HIDE_FROM_ABI void advance_to(iterator __it) { __out_it_ = std::move(__it); }
95		95
96	private:	96	private:
...	@@ -175,13 +175,13 @@ public:	...	@@ -175,13 +175,13 @@ public:
175	__format::__determine_arg_t<basic_format_context, decltype(__arg)>(),	175	__format::__determine_arg_t<basic_format_context, decltype(__arg)>(),
176	__basic_format_arg_value<basic_format_context>(__arg)};	176	__basic_format_arg_value<basic_format_context>(__arg)};
177	};	177	};
178	# if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	178	# if _LIBCPP_STD_VER >= 26
179	return static_cast<_Context*>(__c)->arg(__id).visit(std::move(__visitor));	179	return static_cast<_Context*>(__c)->arg(__id).visit(std::move(__visitor));
180	# else	180	# else
181	_LIBCPP_SUPPRESS_DEPRECATED_PUSH	181	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
182	return std::visit_format_arg(std::move(__visitor), static_cast<_Context*>(__c)->arg(__id));	182	return std::visit_format_arg(std::move(__visitor), static_cast<_Context*>(__c)->arg(__id));
183	_LIBCPP_SUPPRESS_DEPRECATED_POP	183	_LIBCPP_SUPPRESS_DEPRECATED_POP
184	# endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER	184	# endif // _LIBCPP_STD_VER >= 26
185	}) {	185	}) {
186	}	186	}
187		187

lib/libcxx/include/__format/format_parse_context.h+2-2

...	@@ -41,8 +41,8 @@ public:	...	@@ -41,8 +41,8 @@ public:
41	basic_format_parse_context(const basic_format_parse_context&) = delete;	41	basic_format_parse_context(const basic_format_parse_context&) = delete;
42	basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;	42	basic_format_parse_context& operator=(const basic_format_parse_context&) = delete;
43		43
44	_LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept { return __begin_; }	44	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept { return __begin_; }
45	_LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept { return __end_; }	45	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept { return __end_; }
46	_LIBCPP_HIDE_FROM_ABI constexpr void advance_to(const_iterator __it) { __begin_ = __it; }	46	_LIBCPP_HIDE_FROM_ABI constexpr void advance_to(const_iterator __it) { __begin_ = __it; }
47		47
48	_LIBCPP_HIDE_FROM_ABI constexpr size_t next_arg_id() {	48	_LIBCPP_HIDE_FROM_ABI constexpr size_t next_arg_id() {

lib/libcxx/include/__format/formatter_output.h+30-34

...	@@ -45,7 +45,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -45,7 +45,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
45		45
46	namespace __formatter {	46	namespace __formatter {
47		47
48	struct _LIBCPP_EXPORTED_FROM_ABI __padding_size_result {	48	struct __padding_size_result {
49	size_t __before_;	49	size_t __before_;
50	size_t __after_;	50	size_t __after_;
51	};	51	};
...	@@ -151,45 +151,41 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, _CharT __value)	...	@@ -151,45 +151,41 @@ _LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, _CharT __value)
151	}	151	}
152	}	152	}
153		153
154	# if _LIBCPP_HAS_UNICODE
155	template <__fmt_char_type _CharT, output_iterator<const _CharT&> _OutIt>	154	template <__fmt_char_type _CharT, output_iterator<const _CharT&> _OutIt>
156	requires(same_as<_CharT, char>)
157	_LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, __format_spec::__code_point<_CharT> __value) {	155	_LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, __format_spec::__code_point<_CharT> __value) {
158	std::size_t __bytes = std::countl_one(static_cast<unsigned char>(__value.__data[0]));	156	# if _LIBCPP_HAS_UNICODE
159	if (__bytes == 0)	157	if constexpr (same_as<_CharT, char>) {
160	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);	158	std::size_t __bytes = std::countl_one(static_cast<unsigned char>(__value.__data[0]));
161		159	if (__bytes == 0)
162	for (size_t __i = 0; __i < __n; ++__i)	160	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);
163	__out_it = __formatter::__copy(	161
164	std::addressof(__value.__data[0]), std::addressof(__value.__data[0]) + __bytes, std::move(__out_it));	162	for (size_t __i = 0; __i < __n; ++__i)
165	return __out_it;	163	__out_it = __formatter::__copy(
166	}	164	std::addressof(__value.__data[0]), std::addressof(__value.__data[0]) + __bytes, std::move(__out_it));
167		165	return __out_it;
168	# if _LIBCPP_HAS_WIDE_CHARACTERS	166	# if _LIBCPP_HAS_WIDE_CHARACTERS
169	template <__fmt_char_type _CharT, output_iterator<const _CharT&> _OutIt>	167	} else if constexpr (same_as<_CharT, wchar_t>) {
170	requires(same_as<_CharT, wchar_t> && sizeof(wchar_t) == 2)	168	if constexpr (sizeof(wchar_t) == 2) {
171	_LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, __format_spec::__code_point<_CharT> __value) {	169	if (!__unicode::__is_high_surrogate(__value.__data[0]))
172	if (!__unicode::__is_high_surrogate(__value.__data[0]))	170	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);
173	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);	171
174		172	for (size_t __i = 0; __i < __n; ++__i)
175	for (size_t __i = 0; __i < __n; ++__i)	173	__out_it = __formatter::__copy(
176	__out_it = __formatter::__copy(	174	std::addressof(__value.__data[0]), std::addressof(__value.__data[0]) + 2, std::move(__out_it));
177	std::addressof(__value.__data[0]), std::addressof(__value.__data[0]) + 2, std::move(__out_it));	175	return __out_it;
178	return __out_it;	176	} else if constexpr (sizeof(wchar_t) == 4) {
179	}	177	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);
180		178	} else {
181	template <__fmt_char_type _CharT, output_iterator<const _CharT&> _OutIt>	179	static_assert(false, "expected sizeof(wchar_t) to be 2 or 4");
182	requires(same_as<_CharT, wchar_t> && sizeof(wchar_t) == 4)	180	}
183	_LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, __format_spec::__code_point<_CharT> __value) {
184	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);
185	}
186	# endif // _LIBCPP_HAS_WIDE_CHARACTERS	181	# endif // _LIBCPP_HAS_WIDE_CHARACTERS
187	# else // _LIBCPP_HAS_UNICODE	182	} else {
188	template <__fmt_char_type _CharT, output_iterator<const _CharT&> _OutIt>	183	static_assert(false, "Unexpected CharT");
189	_LIBCPP_HIDE_FROM_ABI _OutIt __fill(_OutIt __out_it, size_t __n, __format_spec::__code_point<_CharT> __value) {	184	}
		185	# else // _LIBCPP_HAS_UNICODE
190	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);	186	return __formatter::__fill(std::move(__out_it), __n, __value.__data[0]);
		187	# endif // _LIBCPP_HAS_UNICODE
191	}	188	}
192	# endif // _LIBCPP_HAS_UNICODE
193		189
194	/// Writes the input to the output with the required padding.	190	/// Writes the input to the output with the required padding.
195	///	191	///

lib/libcxx/include/__format/indic_conjunct_break_table.h+3-2

...	@@ -61,7 +61,7 @@	...	@@ -61,7 +61,7 @@
61	#ifndef _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H	61	#ifndef _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H
62	#define _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H	62	#define _LIBCPP___FORMAT_INDIC_CONJUNCT_BREAK_TABLE_H
63		63
64	#include <__algorithm/ranges_upper_bound.h>	64	#include <__algorithm/upper_bound.h>
65	#include <__config>	65	#include <__config>
66	#include <__cstddef/ptrdiff_t.h>	66	#include <__cstddef/ptrdiff_t.h>
67	#include <__iterator/access.h>	67	#include <__iterator/access.h>
...	@@ -531,7 +531,8 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[403] = {	...	@@ -531,7 +531,8 @@ _LIBCPP_HIDE_FROM_ABI inline constexpr uint32_t __entries[403] = {
531	// size. Then the upper bound for code point 3 will return the entry after	531	// size. Then the upper bound for code point 3 will return the entry after
532	// 0x1810. After moving to the previous entry the algorithm arrives at the	532	// 0x1810. After moving to the previous entry the algorithm arrives at the
533	// correct entry.	533	// correct entry.
534	ptrdiff_t __i = std::ranges::upper_bound(__entries, (__code_point << 11) \| 0x7ffu) - __entries;	534	ptrdiff_t __i =
		535	std::upper_bound(std::begin(__entries), std::end(__entries), (__code_point << 11) \| 0x7ffu) - __entries;
535	if (__i == 0)	536	if (__i == 0)
536	return __property::__none;	537	return __property::__none;
537		538

lib/libcxx/include/__format/range_default_formatter.h+2-41

...	@@ -16,10 +16,11 @@	...	@@ -16,10 +16,11 @@
16		16
17	#include <__algorithm/ranges_copy.h>	17	#include <__algorithm/ranges_copy.h>
18	#include <__chrono/statically_widen.h>	18	#include <__chrono/statically_widen.h>
19	#include <__concepts/same_as.h>
20	#include <__config>	19	#include <__config>
21	#include <__format/concepts.h>	20	#include <__format/concepts.h>
		21	#include <__format/fmt_pair_like.h>
22	#include <__format/formatter.h>	22	#include <__format/formatter.h>
		23	#include <__format/range_format.h>
23	#include <__format/range_formatter.h>	24	#include <__format/range_formatter.h>
24	#include <__iterator/back_insert_iterator.h>	25	#include <__iterator/back_insert_iterator.h>
25	#include <__ranges/concepts.h>	26	#include <__ranges/concepts.h>
...	@@ -42,51 +43,11 @@ concept __const_formattable_range =	...	@@ -42,51 +43,11 @@ concept __const_formattable_range =
42	template <class _Rp, class _CharT>	43	template <class _Rp, class _CharT>
43	using __fmt_maybe_const _LIBCPP_NODEBUG = conditional_t<__const_formattable_range<_Rp, _CharT>, const _Rp, _Rp>;	44	using __fmt_maybe_const _LIBCPP_NODEBUG = conditional_t<__const_formattable_range<_Rp, _CharT>, const _Rp, _Rp>;
44		45
45	_LIBCPP_DIAGNOSTIC_PUSH
46	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wshadow")
47	_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wshadow")
48	// This shadows map, set, and string.
49	enum class range_format { disabled, map, set, sequence, string, debug_string };
50	_LIBCPP_DIAGNOSTIC_POP
51
52	// There is no definition of this struct, it's purely intended to be used to	46	// There is no definition of this struct, it's purely intended to be used to
53	// generate diagnostics.	47	// generate diagnostics.
54	template <class _Rp>	48	template <class _Rp>
55	struct __instantiated_the_primary_template_of_format_kind;	49	struct __instantiated_the_primary_template_of_format_kind;
56		50
57	template <class _Rp>
58	constexpr range_format format_kind = [] {
59	// [format.range.fmtkind]/1
60	// A program that instantiates the primary template of format_kind is ill-formed.
61	static_assert(sizeof(_Rp) != sizeof(_Rp), "create a template specialization of format_kind for your type");
62	return range_format::disabled;
63	}();
64
65	template <ranges::input_range _Rp>
66	requires same_as<_Rp, remove_cvref_t<_Rp>>
67	inline constexpr range_format format_kind<_Rp> = [] {
68	// [format.range.fmtkind]/2
69
70	// 2.1 If same_as<remove_cvref_t<ranges::range_reference_t<R>>, R> is true,
71	// Otherwise format_kind<R> is range_format::disabled.
72	if constexpr (same_as<remove_cvref_t<ranges::range_reference_t<_Rp>>, _Rp>)
73	return range_format::disabled;
74	// 2.2 Otherwise, if the qualified-id R::key_type is valid and denotes a type:
75	else if constexpr (requires { typename _Rp::key_type; }) {
76	// 2.2.1 If the qualified-id R::mapped_type is valid and denotes a type ...
77	if constexpr (requires { typename _Rp::mapped_type; } &&
78	// 2.2.1 ... If either U is a specialization of pair or U is a specialization
79	// of tuple and tuple_size_v<U> == 2
80	__fmt_pair_like<remove_cvref_t<ranges::range_reference_t<_Rp>>>)
81	return range_format::map;
82	else
83	// 2.2.2 Otherwise format_kind<R> is range_format::set.
84	return range_format::set;
85	} else
86	// 2.3 Otherwise, format_kind<R> is range_format::sequence.
87	return range_format::sequence;
88	}();
89
90	template <range_format _Kp, ranges::input_range _Rp, class _CharT>	51	template <range_format _Kp, ranges::input_range _Rp, class _CharT>
91	struct __range_default_formatter;	52	struct __range_default_formatter;
92		53

lib/libcxx/include/__format/range_format.h created+71

...	@@ -0,0 +1,71 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___FORMAT_RANGE_FORMAT_H
11	#define _LIBCPP___FORMAT_RANGE_FORMAT_H
12
13	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
14	# pragma GCC system_header
15	#endif
16
17	#include <__concepts/same_as.h>
18	#include <__config>
19	#include <__format/fmt_pair_like.h>
20	#include <__ranges/concepts.h>
21	#include <__type_traits/remove_cvref.h>
22
23	_LIBCPP_BEGIN_NAMESPACE_STD
24
25	#if _LIBCPP_STD_VER >= 23
26
27	_LIBCPP_DIAGNOSTIC_PUSH
28	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wshadow")
29	_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wshadow")
30	// This shadows map, set, and string.
31	enum class range_format { disabled, map, set, sequence, string, debug_string };
32	_LIBCPP_DIAGNOSTIC_POP
33
34	template <class _Rp>
35	constexpr range_format format_kind = [] {
36	// [format.range.fmtkind]/1
37	// A program that instantiates the primary template of format_kind is ill-formed.
38	static_assert(sizeof(_Rp) != sizeof(_Rp), "create a template specialization of format_kind for your type");
39	return range_format::disabled;
40	}();
41
42	template <ranges::input_range _Rp>
43	requires same_as<_Rp, remove_cvref_t<_Rp>>
44	inline constexpr range_format format_kind<_Rp> = [] {
45	// [format.range.fmtkind]/2
46
47	// 2.1 If same_as<remove_cvref_t<ranges::range_reference_t<R>>, R> is true,
48	// Otherwise format_kind<R> is range_format::disabled.
49	if constexpr (same_as<remove_cvref_t<ranges::range_reference_t<_Rp>>, _Rp>)
50	return range_format::disabled;
51	// 2.2 Otherwise, if the qualified-id R::key_type is valid and denotes a type:
52	else if constexpr (requires { typename _Rp::key_type; }) {
53	// 2.2.1 If the qualified-id R::mapped_type is valid and denotes a type ...
54	if constexpr (requires { typename _Rp::mapped_type; } &&
55	// 2.2.1 ... If either U is a specialization of pair or U is a specialization
56	// of tuple and tuple_size_v<U> == 2
57	__fmt_pair_like<remove_cvref_t<ranges::range_reference_t<_Rp>>>)
58	return range_format::map;
59	else
60	// 2.2.2 Otherwise format_kind<R> is range_format::set.
61	return range_format::set;
62	} else
63	// 2.3 Otherwise, format_kind<R> is range_format::sequence.
64	return range_format::sequence;
65	}();
66
67	#endif // _LIBCPP_STD_VER >= 23
68
69	_LIBCPP_END_NAMESPACE_STD
70
71	#endif

lib/libcxx/include/__format/range_formatter.h+1

...	@@ -20,6 +20,7 @@	...	@@ -20,6 +20,7 @@
20	#include <__config>	20	#include <__config>
21	#include <__format/buffer.h>	21	#include <__format/buffer.h>
22	#include <__format/concepts.h>	22	#include <__format/concepts.h>
		23	#include <__format/fmt_pair_like.h>
23	#include <__format/format_context.h>	24	#include <__format/format_context.h>
24	#include <__format/format_error.h>	25	#include <__format/format_error.h>
25	#include <__format/formatter.h>	26	#include <__format/formatter.h>

lib/libcxx/include/__format/width_estimation_table.h+4-2

 @@ -61,9 +61,10 @@
 #ifndef _LIBCPP___FORMAT_WIDTH_ESTIMATION_TABLE_H
 #define _LIBCPP___FORMAT_WIDTH_ESTIMATION_TABLE_H
-#include <__algorithm/ranges_upper_bound.h>
+#include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__cstddef/ptrdiff_t.h>
+#include <__iterator/access.h>
 #include <cstdint>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 @@ -255,7 +256,8 @@ inline constexpr uint32_t __table_upper_bound = 0x0003fffd;
   if (__code_point < (__entries[0] >> 14))
     return 1;
-  ptrdiff_t __i = std::ranges::upper_bound(__entries, (__code_point << 14) | 0x3fffu) - __entries;
+  ptrdiff_t __i =
+      std::upper_bound(std::begin(__entries), std::end(__entries), (__code_point << 14) | 0x3fffu) - __entries;
   if (__i == 0)
     return 1;

lib/libcxx/include/__functional/bind.h+10-15

 @@ -81,17 +81,12 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& __mu(reference_w
   return __t.get();
 }
-template <class _Ti, class... _Uj, size_t... _Indx>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __invoke_result_t<_Ti&, _Uj...>
-__mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>) {
-  return __ti(std::forward<_Uj>(std::get<_Indx>(__uj))...);
-}
 template <class _Ti, class... _Uj, __enable_if_t<is_bind_expression<_Ti>::value, int> = 0>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __invoke_result_t<_Ti&, _Uj...>
 __mu(_Ti& __ti, tuple<_Uj...>& __uj) {
-  typedef typename __make_tuple_indices<sizeof...(_Uj)>::type __indices;
+  return [&]<size_t... _Indices>(__index_sequence<_Indices...>) -> __invoke_result_t<_Ti&, _Uj...> {
-  return std::__mu_expand(__ti, __uj, __indices());
+    return __ti(std::forward<_Uj>(std::get<_Indices>(__uj))...);
+  }(__index_sequence_for<_Uj...>{});
 }
 template <bool _IsPh, class _Ti, class _Uj>
 @@ -191,7 +186,7 @@ struct __bind_return<_Fp, const tuple<_BoundArgs...>, _TupleUj, true> {
 template <class _Fp, class _BoundArgs, size_t... _Indx, class _Args>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __bind_return<_Fp, _BoundArgs, _Args>::type
-__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __tuple_indices<_Indx...>, _Args&& __args) {
+__apply_functor(_Fp& __f, _BoundArgs& __bound_args, __index_sequence<_Indx...>, _Args&& __args) {
   return std::__invoke(__f, std::__mu(std::get<_Indx>(__bound_args), __args)...);
 }
 @@ -205,8 +200,6 @@ private:
   _Fd __f_;
   _Td __bound_args_;
-  typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
 public:
   template <
       class _Gp,
 @@ -219,14 +212,16 @@ public:
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __bind_return<_Fd, _Td, tuple<_Args&&...> >::type
   operator()(_Args&&... __args) {
-    return std::__apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(std::forward<_Args>(__args)...));
+    return std::__apply_functor(
+        __f_, __bound_args_, __index_sequence_for<_BoundArgs...>(), tuple<_Args&&...>(std::forward<_Args>(__args)...));
   }
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
   typename __bind_return<const _Fd, const _Td, tuple<_Args&&...> >::type
   operator()(_Args&&... __args) const {
-    return std::__apply_functor(__f_, __bound_args_, __indices(), tuple<_Args&&...>(std::forward<_Args>(__args)...));
+    return std::__apply_functor(
+        __f_, __bound_args_, __index_sequence_for<_BoundArgs...>(), tuple<_Args&&...>(std::forward<_Args>(__args)...));
   }
 };
 @@ -273,14 +268,14 @@ template <class _Rp, class _Fp, class... _BoundArgs>
 struct is_bind_expression<__bind_r<_Rp, _Fp, _BoundArgs...> > : public true_type {};
 template <class _Fp, class... _BoundArgs>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bind<_Fp, _BoundArgs...>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bind<_Fp, _BoundArgs...>
 bind(_Fp&& __f, _BoundArgs&&... __bound_args) {
   typedef __bind<_Fp, _BoundArgs...> type;
   return type(std::forward<_Fp>(__f), std::forward<_BoundArgs>(__bound_args)...);
 }
 template <class _Rp, class _Fp, class... _BoundArgs>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bind_r<_Rp, _Fp, _BoundArgs...>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __bind_r<_Rp, _Fp, _BoundArgs...>
 bind(_Fp&& __f, _BoundArgs&&... __bound_args) {
   typedef __bind_r<_Rp, _Fp, _BoundArgs...> type;
   return type(std::forward<_Fp>(__f), std::forward<_BoundArgs>(__bound_args)...);

lib/libcxx/include/__functional/bind_back.h+1-1

...	@@ -64,7 +64,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __bind_back(_Fn&& __f, _Args&&... __args) n	...	@@ -64,7 +64,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto __bind_back(_Fn&& __f, _Args&&... __args) n
64		64
65	# if _LIBCPP_STD_VER >= 23	65	# if _LIBCPP_STD_VER >= 23
66	template <class _Fn, class... _Args>	66	template <class _Fn, class... _Args>
67	_LIBCPP_HIDE_FROM_ABI constexpr auto bind_back(_Fn&& __f, _Args&&... __args) {	67	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto bind_back(_Fn&& __f, _Args&&... __args) {
68	static_assert(is_constructible_v<decay_t<_Fn>, _Fn>, "bind_back requires decay_t<F> to be constructible from F");	68	static_assert(is_constructible_v<decay_t<_Fn>, _Fn>, "bind_back requires decay_t<F> to be constructible from F");
69	static_assert(is_move_constructible_v<decay_t<_Fn>>, "bind_back requires decay_t<F> to be move constructible");	69	static_assert(is_move_constructible_v<decay_t<_Fn>>, "bind_back requires decay_t<F> to be move constructible");
70	static_assert((is_constructible_v<decay_t<_Args>, _Args> && ...),	70	static_assert((is_constructible_v<decay_t<_Args>, _Args> && ...),

lib/libcxx/include/__functional/bind_front.h+1-1

...	@@ -43,7 +43,7 @@ struct __bind_front_t : __perfect_forward<__bind_front_op, _Fn, _BoundArgs...> {	...	@@ -43,7 +43,7 @@ struct __bind_front_t : __perfect_forward<__bind_front_op, _Fn, _BoundArgs...> {
43	template <class _Fn, class... _Args>	43	template <class _Fn, class... _Args>
44	requires is_constructible_v<decay_t<_Fn>, _Fn> && is_move_constructible_v<decay_t<_Fn>> &&	44	requires is_constructible_v<decay_t<_Fn>, _Fn> && is_move_constructible_v<decay_t<_Fn>> &&
45	(is_constructible_v<decay_t<_Args>, _Args> && ...) && (is_move_constructible_v<decay_t<_Args>> && ...)	45	(is_constructible_v<decay_t<_Args>, _Args> && ...) && (is_move_constructible_v<decay_t<_Args>> && ...)
46	_LIBCPP_HIDE_FROM_ABI constexpr auto bind_front(_Fn&& __f, _Args&&... __args) {	46	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto bind_front(_Fn&& __f, _Args&&... __args) {
47	return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(std::forward<_Fn>(__f), std::forward<_Args>(__args)...);	47	return __bind_front_t<decay_t<_Fn>, decay_t<_Args>...>(std::forward<_Fn>(__f), std::forward<_Args>(__args)...);
48	}	48	}
49		49

lib/libcxx/include/__functional/function.h+57-75

...	@@ -15,16 +15,14 @@	...	@@ -15,16 +15,14 @@
15	#include <__cstddef/nullptr_t.h>	15	#include <__cstddef/nullptr_t.h>
16	#include <__exception/exception.h>	16	#include <__exception/exception.h>
17	#include <__functional/binary_function.h>	17	#include <__functional/binary_function.h>
18	#include <__functional/invoke.h>
19	#include <__functional/unary_function.h>	18	#include <__functional/unary_function.h>
20	#include <__memory/addressof.h>	19	#include <__memory/addressof.h>
21	#include <__type_traits/aligned_storage.h>	20	#include <__type_traits/aligned_storage.h>
22	#include <__type_traits/decay.h>	21	#include <__type_traits/decay.h>
23	#include <__type_traits/is_core_convertible.h>	22	#include <__type_traits/invoke.h>
24	#include <__type_traits/is_scalar.h>	23	#include <__type_traits/is_scalar.h>
25	#include <__type_traits/is_trivially_constructible.h>	24	#include <__type_traits/is_trivially_constructible.h>
26	#include <__type_traits/is_trivially_destructible.h>	25	#include <__type_traits/is_trivially_destructible.h>
27	#include <__type_traits/is_void.h>
28	#include <__type_traits/strip_signature.h>	26	#include <__type_traits/strip_signature.h>
29	#include <__utility/forward.h>	27	#include <__utility/forward.h>
30	#include <__utility/move.h>	28	#include <__utility/move.h>
...	@@ -95,29 +93,29 @@ template <class _Rp, class _A1, class _A2>	...	@@ -95,29 +93,29 @@ template <class _Rp, class _A1, class _A2>
95	struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> : public __binary_function<_A1, _A2, _Rp> {};	93	struct __maybe_derive_from_binary_function<_Rp(_A1, _A2)> : public __binary_function<_A1, _A2, _Rp> {};
96		94
97	template <class _Fp>	95	template <class _Fp>
98	_LIBCPP_HIDE_FROM_ABI bool __not_null(_Fp const&) {	96	_LIBCPP_HIDE_FROM_ABI bool __is_null(_Fp const&) {
99	return true;	97	return false;
100	}	98	}
101		99
102	template <class _Fp>	100	template <class _Fp>
103	_LIBCPP_HIDE_FROM_ABI bool __not_null(_Fp* __ptr) {	101	_LIBCPP_HIDE_FROM_ABI bool __is_null(_Fp* __ptr) {
104	return __ptr;	102	return !__ptr;
105	}	103	}
106		104
107	template <class _Ret, class _Class>	105	template <class _Ret, class _Class>
108	_LIBCPP_HIDE_FROM_ABI bool __not_null(_Ret _Class::*__ptr) {	106	_LIBCPP_HIDE_FROM_ABI bool __is_null(_Ret _Class::* __ptr) {
109	return __ptr;	107	return !__ptr;
110	}	108	}
111		109
112	template <class _Fp>	110	template <class _Fp>
113	_LIBCPP_HIDE_FROM_ABI bool __not_null(function<_Fp> const& __f) {	111	_LIBCPP_HIDE_FROM_ABI bool __is_null(function<_Fp> const& __f) {
114	return !!__f;	112	return !__f;
115	}	113	}
116		114
117	# if __has_extension(blocks)	115	# if __has_extension(blocks)
118	template <class _Rp, class... _Args>	116	template <class _Rp, class... _Args>
119	_LIBCPP_HIDE_FROM_ABI bool __not_null(_Rp (^__p)(_Args...)) {	117	_LIBCPP_HIDE_FROM_ABI bool __is_null(_Rp (^__p)(_Args...)) {
120	return __p;	118	return !__p;
121	}	119	}
122	# endif	120	# endif
123		121
...	@@ -206,12 +204,13 @@ public:	...	@@ -206,12 +204,13 @@ public:
206	_LIBCPP_HIDE_FROM_ABI explicit __value_func(_Fp&& __f) : __f_(nullptr) {	204	_LIBCPP_HIDE_FROM_ABI explicit __value_func(_Fp&& __f) : __f_(nullptr) {
207	typedef __function::__func<_Fp, _Rp(_ArgTypes...)> _Fun;	205	typedef __function::__func<_Fp, _Rp(_ArgTypes...)> _Fun;
208		206
209	if (__function::__not_null(__f)) {	207	if (__function::__is_null(__f))
210	if (sizeof(_Fun) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) {	208	return;
211	__f_ = ::new (std::addressof(__buf_)) _Fun(std::move(__f));	209
212	} else {	210	if (sizeof(_Fun) <= sizeof(__buf_) && is_nothrow_copy_constructible<_Fp>::value) {
213	__f_ = new _Fun(std::move(__f));	211	__f_ = ::new (std::addressof(__buf_)) _Fun(std::move(__f));
214	}	212	} else {
		213	__f_ = new _Fun(std::move(__f));
215	}	214	}
216	}	215	}
217		216
...	@@ -356,7 +355,31 @@ struct __policy {	...	@@ -356,7 +355,31 @@ struct __policy {
356	// type.	355	// type.
357	template <typename _Fun>	356	template <typename _Fun>
358	_LIBCPP_HIDE_FROM_ABI static const __policy* __create() {	357	_LIBCPP_HIDE_FROM_ABI static const __policy* __create() {
359	return __choose_policy<_Fun>(__use_small_storage<_Fun>());	358	if constexpr (__use_small_storage<_Fun>::value) {
		359	static constexpr __policy __policy = {
		360	nullptr,
		361	nullptr,
		362	false,
		363	# if _LIBCPP_HAS_RTTI
		364	&typeid(_Fun)
		365	# else
		366	nullptr
		367	# endif
		368	};
		369	return &__policy;
		370	} else {
		371	static constexpr __policy __policy = {
		372	std::addressof(__large_clone<_Fun>),
		373	std::addressof(__large_destroy<_Fun>),
		374	false,
		375	# if _LIBCPP_HAS_RTTI
		376	&typeid(_Fun)
		377	# else
		378	nullptr
		379	# endif
		380	};
		381	return &__policy;
		382	}
360	}	383	}
361		384
362	_LIBCPP_HIDE_FROM_ABI static const __policy* __create_empty() {	385	_LIBCPP_HIDE_FROM_ABI static const __policy* __create_empty() {
...	@@ -384,36 +407,6 @@ private:	...	@@ -384,36 +407,6 @@ private:
384	_LIBCPP_HIDE_FROM_ABI static void __large_destroy(void* __s) {	407	_LIBCPP_HIDE_FROM_ABI static void __large_destroy(void* __s) {
385	delete static_cast<_Fun*>(__s);	408	delete static_cast<_Fun*>(__s);
386	}	409	}
387
388	template <typename _Fun>
389	_LIBCPP_HIDE_FROM_ABI static const __policy* __choose_policy(/* is_small = */ false_type) {
390	static constexpr __policy __policy = {
391	std::addressof(__large_clone<_Fun>),
392	std::addressof(__large_destroy<_Fun>),
393	false,
394	# if _LIBCPP_HAS_RTTI
395	&typeid(_Fun)
396	# else
397	nullptr
398	# endif
399	};
400	return &__policy;
401	}
402
403	template <typename _Fun>
404	_LIBCPP_HIDE_FROM_ABI static const __policy* __choose_policy(/* is_small = */ true_type) {
405	static constexpr __policy __policy = {
406	nullptr,
407	nullptr,
408	false,
409	# if _LIBCPP_HAS_RTTI
410	&typeid(_Fun)
411	# else
412	nullptr
413	# endif
414	};
415	return &__policy;
416	}
417	};	410	};
418		411
419	// Used to choose between perfect forwarding or pass-by-value. Pass-by-value is	412	// Used to choose between perfect forwarding or pass-by-value. Pass-by-value is
...	@@ -455,14 +448,15 @@ public:	...	@@ -455,14 +448,15 @@ public:
455		448
456	template <class _Fp, __enable_if_t<!is_same<__decay_t<_Fp>, __policy_func>::value, int> = 0>	449	template <class _Fp, __enable_if_t<!is_same<__decay_t<_Fp>, __policy_func>::value, int> = 0>
457	_LIBCPP_HIDE_FROM_ABI explicit __policy_func(_Fp&& __f) : __policy_(__policy::__create_empty()) {	450	_LIBCPP_HIDE_FROM_ABI explicit __policy_func(_Fp&& __f) : __policy_(__policy::__create_empty()) {
458	if (__function::__not_null(__f)) {	451	if (__function::__is_null(__f))
459	__func_ = __call_func<_Fp>;	452	return;
460	__policy_ = __policy::__create<_Fp>();	453
461	if (__use_small_storage<_Fp>()) {	454	__func_ = __call_func<_Fp>;
462	::new ((void*)&__buf_.__small) _Fp(std::move(__f));	455	__policy_ = __policy::__create<_Fp>();
463	} else {	456	if (__use_small_storage<_Fp>()) {
464	__buf_.__large = ::new _Fp(std::move(__f));	457	::new ((void*)&__buf_.__small) _Fp(std::move(__f));
465	}	458	} else {
		459	__buf_.__large = ::new _Fp(std::move(__f));
466	}	460	}
467	}	461	}
468		462
...	@@ -615,21 +609,9 @@ class function<_Rp(_ArgTypes...)>	...	@@ -615,21 +609,9 @@ class function<_Rp(_ArgTypes...)>
615		609
616	__func __f_;	610	__func __f_;
617		611
618	template <class _Fp,
619	bool = _And<_IsNotSame<__remove_cvref_t<_Fp>, function>, __is_invocable<_Fp, _ArgTypes...> >::value>
620	struct __callable;
621	template <class _Fp>
622	struct __callable<_Fp, true> {
623	static const bool value =
624	is_void<_Rp>::value \|\| __is_core_convertible<__invoke_result_t<_Fp, _ArgTypes...>, _Rp>::value;
625	};
626	template <class _Fp>
627	struct __callable<_Fp, false> {
628	static const bool value = false;
629	};
630
631	template <class _Fp>	612	template <class _Fp>
632	using _EnableIfLValueCallable _LIBCPP_NODEBUG = __enable_if_t<__callable<_Fp&>::value>;	613	using _EnableIfLValueCallable _LIBCPP_NODEBUG = __enable_if_t<
		614	_And<_IsNotSame<__remove_cvref_t<_Fp>, function>, __is_invocable_r<_Rp, _Fp&, _ArgTypes...>>::value>;
633		615
634	public:	616	public:
635	typedef _Rp result_type;	617	typedef _Rp result_type;
...	@@ -690,11 +672,11 @@ public:	...	@@ -690,11 +672,11 @@ public:
690		672
691	# if _LIBCPP_HAS_RTTI	673	# if _LIBCPP_HAS_RTTI
692	// function target access:	674	// function target access:
693	_LIBCPP_HIDE_FROM_ABI const std::type_info& target_type() const _NOEXCEPT;	675	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const std::type_info& target_type() const _NOEXCEPT;
694	template <typename _Tp>	676	template <typename _Tp>
695	_LIBCPP_HIDE_FROM_ABI _Tp* target() _NOEXCEPT;	677	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Tp* target() _NOEXCEPT;
696	template <typename _Tp>	678	template <typename _Tp>
697	_LIBCPP_HIDE_FROM_ABI const _Tp* target() const _NOEXCEPT;	679	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const _Tp* target() const _NOEXCEPT;
698	# endif // _LIBCPP_HAS_RTTI	680	# endif // _LIBCPP_HAS_RTTI
699	};	681	};
700		682

lib/libcxx/include/__functional/hash.h+1-10

 @@ -433,13 +433,10 @@ struct __hash_impl<long double> : __scalar_hash<long double> {
 template <class _Tp>
 struct hash : public __hash_impl<_Tp> {};
-#if _LIBCPP_STD_VER >= 17
 template <>
 struct hash<nullptr_t> : public __unary_function<nullptr_t, size_t> {
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(nullptr_t) const _NOEXCEPT { return 662607004ull; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t operator()(nullptr_t) const _NOEXCEPT { return 662607004ull; }
 };
-#endif
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Key, class _Hash>
 @@ -452,18 +449,12 @@ template <class _Key, class _Hash = hash<_Key> >
 using __has_enabled_hash _LIBCPP_NODEBUG =
     integral_constant<bool, __check_hash_requirements<_Key, _Hash>::value && is_default_constructible<_Hash>::value >;
-#  if _LIBCPP_STD_VER >= 17
 template <class _Type, class>
 using __enable_hash_helper_imp _LIBCPP_NODEBUG = _Type;
 template <class _Type, class... _Keys>
 using __enable_hash_helper _LIBCPP_NODEBUG =
     __enable_hash_helper_imp<_Type, __enable_if_t<__all<__has_enabled_hash<_Keys>::value...>::value> >;
-#  else
-template <class _Type, class...>
-using __enable_hash_helper _LIBCPP_NODEBUG = _Type;
-#  endif
 #endif // !_LIBCPP_CXX03_LANG
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__functional/identity.h+1-1

...	@@ -44,7 +44,7 @@ struct __is_identity<reference_wrapper<const __identity> > : true_type {};	...	@@ -44,7 +44,7 @@ struct __is_identity<reference_wrapper<const __identity> > : true_type {};
44		44
45	struct identity {	45	struct identity {
46	template <class _Tp>	46	template <class _Tp>
47	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator()(_Tp&& __t) const noexcept {	47	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator()(_LIBCPP_LIFETIMEBOUND _Tp&& __t) const noexcept {
48	return std::forward<_Tp>(__t);	48	return std::forward<_Tp>(__t);
49	}	49	}
50		50

lib/libcxx/include/__functional/is_transparent.h+8

...	@@ -29,6 +29,14 @@ inline const bool __is_transparent_v<_Tp, _Key, __void_t<typename _Tp::is_transp	...	@@ -29,6 +29,14 @@ inline const bool __is_transparent_v<_Tp, _Key, __void_t<typename _Tp::is_transp
29		29
30	#endif	30	#endif
31		31
		32	// Two types are considered transparently comparable if `comparator(key, arg)` is equivalent to `comparator(key,
		33	// <implicit cast to KeyT>(arg))`.
		34	//
		35	// This is different from `__is_transparent_v`, which is only a property of the comparator and doesn't provide
		36	// additional semantic guarantees.
		37	template <class _Comparator, class _KeyT, class _Arg, class = void>
		38	inline const bool __is_transparently_comparable_v = false;
		39
32	_LIBCPP_END_NAMESPACE_STD	40	_LIBCPP_END_NAMESPACE_STD
33		41
34	#endif // _LIBCPP___FUNCTIONAL_IS_TRANSPARENT	42	#endif // _LIBCPP___FUNCTIONAL_IS_TRANSPARENT

lib/libcxx/include/__functional/mem_fn.h+2-1

...	@@ -43,7 +43,8 @@ public:	...	@@ -43,7 +43,8 @@ public:
43	};	43	};
44		44
45	template <class _Rp, class _Tp>	45	template <class _Rp, class _Tp>
46	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __mem_fn<_Rp _Tp::> mem_fn(_Rp _Tp::__pm) _NOEXCEPT {	46	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __mem_fn<_Rp _Tp::*>
		47	mem_fn(_Rp _Tp::* __pm) _NOEXCEPT {
47	return __mem_fn<_Rp _Tp::*>(__pm);	48	return __mem_fn<_Rp _Tp::*>(__pm);
48	}	49	}
49		50

lib/libcxx/include/__functional/operations.h+18

...	@@ -15,7 +15,9 @@	...	@@ -15,7 +15,9 @@
15	#include <__functional/unary_function.h>	15	#include <__functional/unary_function.h>
16	#include <__fwd/functional.h>	16	#include <__fwd/functional.h>
17	#include <__type_traits/desugars_to.h>	17	#include <__type_traits/desugars_to.h>
		18	#include <__type_traits/is_generic_transparent_comparator.h>
18	#include <__type_traits/is_integral.h>	19	#include <__type_traits/is_integral.h>
		20	#include <__type_traits/make_transparent.h>
19	#include <__utility/forward.h>	21	#include <__utility/forward.h>
20		22
21	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	23	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -377,6 +379,14 @@ struct less<void> {	...	@@ -377,6 +379,14 @@ struct less<void> {
377	typedef void is_transparent;	379	typedef void is_transparent;
378	};	380	};
379		381
		382	template <class _Tp>
		383	struct __make_transparent<_Tp, less<_Tp> > {
		384	using type _LIBCPP_NODEBUG = less<>;
		385	};
		386
		387	template <>
		388	inline const bool __is_generic_transparent_comparator_v<less<>> = true;
		389
380	template <class _Tp, class _Up>	390	template <class _Tp, class _Up>
381	inline const bool __desugars_to_v<__less_tag, less<>, _Tp, _Up> = true;	391	inline const bool __desugars_to_v<__less_tag, less<>, _Tp, _Up> = true;
382		392
...	@@ -466,6 +476,14 @@ struct greater<void> {	...	@@ -466,6 +476,14 @@ struct greater<void> {
466		476
467	template <class _Tp, class _Up>	477	template <class _Tp, class _Up>
468	inline const bool __desugars_to_v<__greater_tag, greater<>, _Tp, _Up> = true;	478	inline const bool __desugars_to_v<__greater_tag, greater<>, _Tp, _Up> = true;
		479
		480	template <class _Tp>
		481	struct __make_transparent<_Tp, greater<_Tp>> {
		482	using type _LIBCPP_NODEBUG = greater<>;
		483	};
		484
		485	template <>
		486	inline const bool __is_generic_transparent_comparator_v<greater<>> = true;
469	#endif	487	#endif
470		488
471	// Logical operations	489	// Logical operations

lib/libcxx/include/__functional/ranges_operations.h+7

 @@ -14,6 +14,7 @@
 #include <__concepts/totally_ordered.h>
 #include <__config>
 #include <__type_traits/desugars_to.h>
+#include <__type_traits/is_generic_transparent_comparator.h>
 #include <__utility/forward.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 @@ -108,6 +109,12 @@ inline const bool __desugars_to_v<__less_tag, ranges::less, _Tp, _Up> = true;
 template <class _Tp, class _Up>
 inline const bool __desugars_to_v<__greater_tag, ranges::greater, _Tp, _Up> = true;
+template <>
+inline const bool __is_generic_transparent_comparator_v<ranges::less> = true;
+template <>
+inline const bool __is_generic_transparent_comparator_v<ranges::greater> = true;
 #endif // _LIBCPP_STD_VER >= 20
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__functional/reference_wrapper.h+7-5

 @@ -58,7 +58,7 @@ public:
   // access
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator type&() const _NOEXCEPT { return *__f_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 type& get() const _NOEXCEPT { return *__f_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 type& get() const _NOEXCEPT { return *__f_; }
   // invoke
   template <class... _ArgTypes>
 @@ -128,23 +128,25 @@ reference_wrapper(_Tp&) -> reference_wrapper<_Tp>;
 #endif
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<_Tp> ref(_Tp& __t) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<_Tp> ref(_Tp& __t) _NOEXCEPT {
   return reference_wrapper<_Tp>(__t);
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<_Tp>
 ref(reference_wrapper<_Tp> __t) _NOEXCEPT {
   return __t;
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<const _Tp> cref(const _Tp& __t) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<const _Tp>
+cref(const _Tp& __t) _NOEXCEPT {
   return reference_wrapper<const _Tp>(__t);
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<const _Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference_wrapper<const _Tp>
 cref(reference_wrapper<_Tp> __t) _NOEXCEPT {
   return __t;
 }

lib/libcxx/include/__functional/weak_result_type.h+14-28

 @@ -13,9 +13,9 @@
 #include <__config>
 #include <__functional/binary_function.h>
 #include <__functional/unary_function.h>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/invoke.h>
 #include <__type_traits/is_same.h>
+#include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 @@ -24,50 +24,36 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <class _Tp>
+template <class _Tp, class = void>
-struct __has_result_type {
+inline const bool __has_result_type_v = false;
-private:
-  template <class _Up>
-  static false_type __test(...);
-  template <class _Up>
-  static true_type __test(typename _Up::result_type* = 0);
-public:
+template <class _Tp>
-  static const bool value = decltype(__test<_Tp>(0))::value;
+inline const bool __has_result_type_v<_Tp, __void_t<typename _Tp::result_type*> > = true;
-};
 // __weak_result_type
 template <class _Tp>
 struct __derives_from_unary_function {
 private:
-  struct __two {
+  static void __find_base(...);
-    char __lx;
-    char __lxx;
-  };
-  static __two __test(...);
   template <class _Ap, class _Rp>
-  static __unary_function<_Ap, _Rp> __test(const volatile __unary_function<_Ap, _Rp>*);
+  static __unary_function<_Ap, _Rp> __find_base(const volatile __unary_function<_Ap, _Rp>*);
 public:
-  static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
+  using type              = decltype(__find_base(static_cast<_Tp*>(nullptr)));
-  typedef decltype(__test((_Tp*)0)) type;
+  static const bool value = !is_same<type, void>::value;
 };
 template <class _Tp>
 struct __derives_from_binary_function {
 private:
-  struct __two {
+  static void __find_base(...);
-    char __lx;
-    char __lxx;
-  };
-  static __two __test(...);
   template <class _A1, class _A2, class _Rp>
-  static __binary_function<_A1, _A2, _Rp> __test(const volatile __binary_function<_A1, _A2, _Rp>*);
+  static __binary_function<_A1, _A2, _Rp> __find_base(const volatile __binary_function<_A1, _A2, _Rp>*);
 public:
-  static const bool value = !is_same<decltype(__test((_Tp*)0)), __two>::value;
+  using type              = decltype(__find_base(static_cast<_Tp*>(nullptr)));
-  typedef decltype(__test((_Tp*)0)) type;
+  static const bool value = !is_same<type, void>::value;
 };
 template <class _Tp, bool = __derives_from_unary_function<_Tp>::value>
 @@ -85,7 +71,7 @@ struct __maybe_derive_from_binary_function // bool is true
 template <class _Tp>
 struct __maybe_derive_from_binary_function<_Tp, false> {};
-template <class _Tp, bool = __has_result_type<_Tp>::value>
+template <class _Tp, bool = __has_result_type_v<_Tp> >
 struct __weak_result_type_imp // bool is true
     : public __maybe_derive_from_unary_function<_Tp>,
       public __maybe_derive_from_binary_function<_Tp> {

lib/libcxx/include/__fwd/ios.h+1-1

...	@@ -31,7 +31,7 @@ using wios = basic_ios<wchar_t>;	...	@@ -31,7 +31,7 @@ using wios = basic_ios<wchar_t>;
31	template <class _CharT, class _Traits>	31	template <class _CharT, class _Traits>
32	class _LIBCPP_PREFERRED_NAME(ios) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wios)) basic_ios;	32	class _LIBCPP_PREFERRED_NAME(ios) _LIBCPP_IF_WIDE_CHARACTERS(_LIBCPP_PREFERRED_NAME(wios)) basic_ios;
33		33
34	#if defined(_NEWLIB_VERSION)	34	#if _LIBCPP_LIBC_NEWLIB
35	// On newlib, off_t is 'long int'	35	// On newlib, off_t is 'long int'
36	using streamoff = long int; // for char_traits in <string>	36	using streamoff = long int; // for char_traits in <string>
37	#else	37	#else

lib/libcxx/include/__fwd/tuple.h+14

...	@@ -21,11 +21,25 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -21,11 +21,25 @@ _LIBCPP_BEGIN_NAMESPACE_STD
21	template <size_t, class>	21	template <size_t, class>
22	struct tuple_element;	22	struct tuple_element;
23		23
		24	template <size_t _Np, class _Tp>
		25	using __tuple_element_t _LIBCPP_NODEBUG = typename tuple_element<_Np, _Tp>::type;
		26
24	#ifndef _LIBCPP_CXX03_LANG	27	#ifndef _LIBCPP_CXX03_LANG
25		28
26	template <class...>	29	template <class...>
27	class tuple;	30	class tuple;
28		31
		32	template <class>
		33	inline const bool __is_tuple_v = false;
		34
		35	template <class... _Tp>
		36	inline const bool __is_tuple_v<tuple<_Tp...>> = true;
		37
		38	template <size_t _Ip, class... _Tp>
		39	struct tuple_element<_Ip, tuple<_Tp...> > {
		40	using type _LIBCPP_NODEBUG = __type_pack_element<_Ip, _Tp...>;
		41	};
		42
29	template <class>	43	template <class>
30	struct tuple_size;	44	struct tuple_size;
31		45

lib/libcxx/include/__hash_table+371-357

...	@@ -10,6 +10,7 @@	...	@@ -10,6 +10,7 @@
10	#ifndef _LIBCPP___HASH_TABLE	10	#ifndef _LIBCPP___HASH_TABLE
11	#define _LIBCPP___HASH_TABLE	11	#define _LIBCPP___HASH_TABLE
12		12
		13	#include <__algorithm/fill_n.h>
13	#include <__algorithm/max.h>	14	#include <__algorithm/max.h>
14	#include <__algorithm/min.h>	15	#include <__algorithm/min.h>
15	#include <__assert>	16	#include <__assert>
...	@@ -28,7 +29,6 @@	...	@@ -28,7 +29,6 @@
28	#include <__memory/swap_allocator.h>	29	#include <__memory/swap_allocator.h>
29	#include <__memory/unique_ptr.h>	30	#include <__memory/unique_ptr.h>
30	#include <__new/launder.h>	31	#include <__new/launder.h>
31	#include <__type_traits/can_extract_key.h>
32	#include <__type_traits/copy_cvref.h>	32	#include <__type_traits/copy_cvref.h>
33	#include <__type_traits/enable_if.h>	33	#include <__type_traits/enable_if.h>
34	#include <__type_traits/invoke.h>	34	#include <__type_traits/invoke.h>
...	@@ -44,7 +44,9 @@	...	@@ -44,7 +44,9 @@
44	#include <__utility/forward.h>	44	#include <__utility/forward.h>
45	#include <__utility/move.h>	45	#include <__utility/move.h>
46	#include <__utility/pair.h>	46	#include <__utility/pair.h>
		47	#include <__utility/scope_guard.h>
47	#include <__utility/swap.h>	48	#include <__utility/swap.h>
		49	#include <__utility/try_key_extraction.h>
48	#include <limits>	50	#include <limits>
49		51
50	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	52	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -81,18 +83,6 @@ struct __hash_node_base {	...	@@ -81,18 +83,6 @@ struct __hash_node_base {
81	typedef _NodePtr __node_pointer;	83	typedef _NodePtr __node_pointer;
82	typedef __node_base_pointer __next_pointer;	84	typedef __node_base_pointer __next_pointer;
83		85
84	// TODO(LLVM 22): Remove this check
85	#ifndef _LIBCPP_ABI_FIX_UNORDERED_NODE_POINTER_UB
86	static_assert(sizeof(__node_base_pointer) == sizeof(__node_pointer) && _LIBCPP_ALIGNOF(__node_base_pointer) ==
87	_LIBCPP_ALIGNOF(__node_pointer),
88	"It looks like you are using std::__hash_table (an implementation detail for the unordered containers) "
89	"with a fancy pointer type that thas a different representation depending on whether it points to a "
90	"__hash_table base pointer or a __hash_table node pointer (both of which are implementation details of "
91	"the standard library). This means that your ABI is being broken between LLVM 19 and LLVM 20. If you "
92	"don't care about your ABI being broken, define the _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB macro to "
93	"silence this diagnostic.");
94	#endif
95
96	__next_pointer __next_;	86	__next_pointer __next_;
97		87
98	_LIBCPP_HIDE_FROM_ABI __next_pointer __ptr() _NOEXCEPT {	88	_LIBCPP_HIDE_FROM_ABI __next_pointer __ptr() _NOEXCEPT {
...	@@ -122,6 +112,19 @@ struct __get_hash_node_value_type<__hash_value_type<_Key, _Tp> > {	...	@@ -122,6 +112,19 @@ struct __get_hash_node_value_type<__hash_value_type<_Key, _Tp> > {
122	template <class _Tp>	112	template <class _Tp>
123	using __get_hash_node_value_type_t _LIBCPP_NODEBUG = typename __get_hash_node_value_type<_Tp>::type;	113	using __get_hash_node_value_type_t _LIBCPP_NODEBUG = typename __get_hash_node_value_type<_Tp>::type;
124		114
		115	template <class _Tp>
		116	struct __get_hash_node_key_type {
		117	using type _LIBCPP_NODEBUG = _Tp;
		118	};
		119
		120	template <class _Key, class _Tp>
		121	struct __get_hash_node_key_type<__hash_value_type<_Key, _Tp> > {
		122	using type _LIBCPP_NODEBUG = _Key;
		123	};
		124
		125	template <class _Tp>
		126	using __get_hash_node_key_type_t _LIBCPP_NODEBUG = typename __get_hash_node_key_type<_Tp>::type;
		127
125	template <class _Tp, class _VoidPtr>	128	template <class _Tp, class _VoidPtr>
126	struct __hash_node : public __hash_node_base< __rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> > > {	129	struct __hash_node : public __hash_node_base< __rebind_pointer_t<_VoidPtr, __hash_node<_Tp, _VoidPtr> > > {
127	using __node_value_type _LIBCPP_NODEBUG = __get_hash_node_value_type_t<_Tp>;	130	using __node_value_type _LIBCPP_NODEBUG = __get_hash_node_value_type_t<_Tp>;
...	@@ -152,7 +155,12 @@ public:	...	@@ -152,7 +155,12 @@ public:
152	}	155	}
153	#endif	156	#endif
154		157
155	_LIBCPP_HIDE_FROM_ABI explicit __hash_node(__next_pointer __next, size_t __hash) : _Base(__next), __hash_(__hash) {}	158	template <class _Alloc, class... _Args>
		159	_LIBCPP_HIDE_FROM_ABI explicit __hash_node(size_t __hash, _Alloc& __na, _Args&&... __args)
		160	: _Base(nullptr), __hash_(__hash) {
		161	allocator_traits<_Alloc>::construct(__na, std::addressof(__get_value()), std::forward<_Args>(__args)...);
		162	}
		163
156	_LIBCPP_HIDE_FROM_ABI ~__hash_node() {}	164	_LIBCPP_HIDE_FROM_ABI ~__hash_node() {}
157	};	165	};
158		166
...	@@ -182,85 +190,16 @@ class __hash_map_iterator;	...	@@ -182,85 +190,16 @@ class __hash_map_iterator;
182	template <class _HashIterator>	190	template <class _HashIterator>
183	class __hash_map_const_iterator;	191	class __hash_map_const_iterator;
184		192
185	template <class _Tp>
186	struct __hash_key_value_types {
187	static_assert(!is_reference<_Tp>::value && !is_const<_Tp>::value, "");
188	typedef _Tp key_type;
189	typedef _Tp __node_value_type;
190	typedef _Tp __container_value_type;
191	static const bool __is_map = false;
192
193	_LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(_Tp const& __v) { return __v; }
194	_LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(__node_value_type const& __v) { return __v; }
195	_LIBCPP_HIDE_FROM_ABI static __container_value_type* __get_ptr(__node_value_type& __n) { return std::addressof(__n); }
196	_LIBCPP_HIDE_FROM_ABI static __container_value_type&& __move(__node_value_type& __v) { return std::move(__v); }
197	};
198
199	template <class _Key, class _Tp>
200	struct __hash_key_value_types<__hash_value_type<_Key, _Tp> > {
201	typedef _Key key_type;
202	typedef _Tp mapped_type;
203	typedef __hash_value_type<_Key, _Tp> __node_value_type;
204	typedef pair<const _Key, _Tp> __container_value_type;
205	typedef __container_value_type __map_value_type;
206	static const bool __is_map = true;
207
208	_LIBCPP_HIDE_FROM_ABI static key_type const& __get_key(__container_value_type const& __v) { return __v.first; }
209
210	template <class _Up, __enable_if_t<is_same<__remove_cvref_t<_Up>, __node_value_type>::value, int> = 0>
211	_LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(_Up& __t) {
212	return __t.__get_value();
213	}
214
215	template <class _Up, __enable_if_t<is_same<__remove_cvref_t<_Up>, __container_value_type>::value, int> = 0>
216	_LIBCPP_HIDE_FROM_ABI static __container_value_type const& __get_value(_Up& __t) {
217	return __t;
218	}
219
220	_LIBCPP_HIDE_FROM_ABI static __container_value_type* __get_ptr(__container_value_type& __n) {
221	return std::addressof(__n);
222	}
223	_LIBCPP_HIDE_FROM_ABI static pair<key_type&&, mapped_type&&> __move(__node_value_type& __v) { return __v.__move(); }
224	};
225
226	template <class _Tp, class _AllocPtr, class _KVTypes = __hash_key_value_types<_Tp>, bool = _KVTypes::__is_map>
227	struct __hash_map_pointer_types {};
228
229	template <class _Tp, class _AllocPtr, class _KVTypes>
230	struct __hash_map_pointer_types<_Tp, _AllocPtr, _KVTypes, true> {
231	typedef typename _KVTypes::__map_value_type _Mv;
232	typedef __rebind_pointer_t<_AllocPtr, _Mv> __map_value_type_pointer;
233	typedef __rebind_pointer_t<_AllocPtr, const _Mv> __const_map_value_type_pointer;
234	};
235
236	template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>	193	template <class _NodePtr, class _NodeT = typename pointer_traits<_NodePtr>::element_type>
237	struct __hash_node_types;	194	struct __hash_node_types;
238		195
239	template <class _NodePtr, class _Tp, class _VoidPtr>	196	template <class _NodePtr, class _Tp, class _VoidPtr>
240	struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> >	197	struct __hash_node_types<_NodePtr, __hash_node<_Tp, _VoidPtr> > {
241	: public __hash_key_value_types<_Tp>,
242	__hash_map_pointer_types<_Tp, _VoidPtr>
243
244	{
245	typedef __hash_key_value_types<_Tp> __base;
246
247	public:
248	typedef ptrdiff_t difference_type;
249	typedef size_t size_type;
250
251	typedef __rebind_pointer_t<_NodePtr, void> __void_pointer;
252
253	typedef typename pointer_traits<_NodePtr>::element_type __node_type;	198	typedef typename pointer_traits<_NodePtr>::element_type __node_type;
254	typedef _NodePtr __node_pointer;
255		199
256	typedef __hash_node_base<__node_pointer> __node_base_type;	200	typedef typename __hash_node_base<_NodePtr>::__next_pointer __next_pointer;
257	typedef __rebind_pointer_t<_NodePtr, __node_base_type> __node_base_pointer;
258
259	typedef typename __node_base_type::__next_pointer __next_pointer;
260		201
261	using __node_value_type _LIBCPP_NODEBUG = __get_hash_node_value_type_t<_Tp>;	202	using __node_value_type _LIBCPP_NODEBUG = __get_hash_node_value_type_t<_Tp>;
262	typedef __rebind_pointer_t<_VoidPtr, __node_value_type> __node_value_type_pointer;
263	typedef __rebind_pointer_t<_VoidPtr, const __node_value_type> __const_node_value_type_pointer;
264		203
265	private:	204	private:
266	static_assert(!is_const<__node_type>::value, "_NodePtr should never be a pointer to const");	205	static_assert(!is_const<__node_type>::value, "_NodePtr should never be a pointer to const");
...	@@ -281,13 +220,6 @@ struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __has	...	@@ -281,13 +220,6 @@ struct __hash_node_types_from_iterator<__hash_local_iterator<_NodePtr> > : __has
281	template <class _NodePtr>	220	template <class _NodePtr>
282	struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};	221	struct __hash_node_types_from_iterator<__hash_const_local_iterator<_NodePtr> > : __hash_node_types<_NodePtr> {};
283		222
284	template <class _NodeValueTp, class _VoidPtr>
285	struct __make_hash_node_types {
286	typedef __hash_node<_NodeValueTp, _VoidPtr> _NodeTp;
287	typedef __rebind_pointer_t<_VoidPtr, _NodeTp> _NodePtr;
288	typedef __hash_node_types<_NodePtr> type;
289	};
290
291	template <class _NodePtr>	223	template <class _NodePtr>
292	class __hash_iterator {	224	class __hash_iterator {
293	typedef __hash_node_types<_NodePtr> _NodeTypes;	225	typedef __hash_node_types<_NodePtr> _NodeTypes;
...	@@ -299,9 +231,9 @@ class __hash_iterator {	...	@@ -299,9 +231,9 @@ class __hash_iterator {
299	public:	231	public:
300	typedef forward_iterator_tag iterator_category;	232	typedef forward_iterator_tag iterator_category;
301	typedef typename _NodeTypes::__node_value_type value_type;	233	typedef typename _NodeTypes::__node_value_type value_type;
302	typedef typename _NodeTypes::difference_type difference_type;	234	using difference_type = ptrdiff_t;
303	typedef value_type& reference;	235	typedef value_type& reference;
304	typedef typename _NodeTypes::__node_value_type_pointer pointer;	236	using pointer = __rebind_pointer_t<_NodePtr, value_type>;
305		237
306	_LIBCPP_HIDE_FROM_ABI __hash_iterator() _NOEXCEPT : __node_(nullptr) {}	238	_LIBCPP_HIDE_FROM_ABI __hash_iterator() _NOEXCEPT : __node_(nullptr) {}
307		239
...	@@ -366,9 +298,9 @@ public:	...	@@ -366,9 +298,9 @@ public:
366		298
367	typedef forward_iterator_tag iterator_category;	299	typedef forward_iterator_tag iterator_category;
368	typedef typename _NodeTypes::__node_value_type value_type;	300	typedef typename _NodeTypes::__node_value_type value_type;
369	typedef typename _NodeTypes::difference_type difference_type;	301	using difference_type = ptrdiff_t;
370	typedef const value_type& reference;	302	typedef const value_type& reference;
371	typedef typename _NodeTypes::__const_node_value_type_pointer pointer;	303	using pointer = __rebind_pointer_t<_NodePtr, const value_type>;
372		304
373	_LIBCPP_HIDE_FROM_ABI __hash_const_iterator() _NOEXCEPT : __node_(nullptr) {}	305	_LIBCPP_HIDE_FROM_ABI __hash_const_iterator() _NOEXCEPT : __node_(nullptr) {}
374		306
...	@@ -431,9 +363,9 @@ class __hash_local_iterator {	...	@@ -431,9 +363,9 @@ class __hash_local_iterator {
431	public:	363	public:
432	typedef forward_iterator_tag iterator_category;	364	typedef forward_iterator_tag iterator_category;
433	typedef typename _NodeTypes::__node_value_type value_type;	365	typedef typename _NodeTypes::__node_value_type value_type;
434	typedef typename _NodeTypes::difference_type difference_type;	366	using difference_type = ptrdiff_t;
435	typedef value_type& reference;	367	typedef value_type& reference;
436	typedef typename _NodeTypes::__node_value_type_pointer pointer;	368	using pointer = __rebind_pointer_t<_NodePtr, value_type>;
437		369
438	_LIBCPP_HIDE_FROM_ABI __hash_local_iterator() _NOEXCEPT : __node_(nullptr) {}	370	_LIBCPP_HIDE_FROM_ABI __hash_local_iterator() _NOEXCEPT : __node_(nullptr) {}
439		371
...	@@ -509,9 +441,9 @@ public:	...	@@ -509,9 +441,9 @@ public:
509		441
510	typedef forward_iterator_tag iterator_category;	442	typedef forward_iterator_tag iterator_category;
511	typedef typename _NodeTypes::__node_value_type value_type;	443	typedef typename _NodeTypes::__node_value_type value_type;
512	typedef typename _NodeTypes::difference_type difference_type;	444	using difference_type = ptrdiff_t;
513	typedef const value_type& reference;	445	typedef const value_type& reference;
514	typedef typename _NodeTypes::__const_node_value_type_pointer pointer;	446	using pointer = __rebind_pointer_t<_ConstNodePtr, const value_type>;
515		447
516	_LIBCPP_HIDE_FROM_ABI __hash_const_local_iterator() _NOEXCEPT : __node_(nullptr) {}	448	_LIBCPP_HIDE_FROM_ABI __hash_const_local_iterator() _NOEXCEPT : __node_(nullptr) {}
517		449
...	@@ -617,8 +549,6 @@ public:	...	@@ -617,8 +549,6 @@ public:
617	typedef typename __alloc_traits::pointer pointer;	549	typedef typename __alloc_traits::pointer pointer;
618		550
619	private:	551	private:
620	typedef __hash_node_types<pointer> _NodeTypes;
621
622	allocator_type& __na_;	552	allocator_type& __na_;
623		553
624	public:	554	public:
...	@@ -633,7 +563,7 @@ public:	...	@@ -633,7 +563,7 @@ public:
633		563
634	_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {	564	_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
635	if (__value_constructed) {	565	if (__value_constructed) {
636	__alloc_traits::destroy(__na_, _NodeTypes::__get_ptr(__p->__get_value()));	566	__alloc_traits::destroy(__na_, std::addressof(__p->__get_value()));
637	std::__destroy_at(std::addressof(*__p));	567	std::__destroy_at(std::addressof(*__p));
638	}	568	}
639	if (__p)	569	if (__p)
...	@@ -684,18 +614,16 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>	...	@@ -684,18 +614,16 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
684	class __hash_table {	614	class __hash_table {
685	public:	615	public:
686	using value_type = __get_hash_node_value_type_t<_Tp>;	616	using value_type = __get_hash_node_value_type_t<_Tp>;
		617	using key_type = __get_hash_node_key_type_t<_Tp>;
		618
687	typedef _Hash hasher;	619	typedef _Hash hasher;
688	typedef _Equal key_equal;	620	typedef _Equal key_equal;
689	typedef _Alloc allocator_type;	621	typedef _Alloc allocator_type;
690		622
691	private:	623	private:
692	typedef allocator_traits<allocator_type> __alloc_traits;	624	typedef allocator_traits<allocator_type> __alloc_traits;
693	typedef typename __make_hash_node_types<_Tp, typename __alloc_traits::void_pointer>::type _NodeTypes;
694		625
695	public:	626	public:
696	typedef typename _NodeTypes::__node_value_type __node_value_type;
697	typedef typename _NodeTypes::__container_value_type __container_value_type;
698	typedef typename _NodeTypes::key_type key_type;
699	typedef value_type& reference;	627	typedef value_type& reference;
700	typedef const value_type& const_reference;	628	typedef const value_type& const_reference;
701	typedef typename __alloc_traits::pointer pointer;	629	typedef typename __alloc_traits::pointer pointer;
...	@@ -703,22 +631,23 @@ public:	...	@@ -703,22 +631,23 @@ public:
703	#ifndef _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE	631	#ifndef _LIBCPP_ABI_FIX_UNORDERED_CONTAINER_SIZE_TYPE
704	typedef typename __alloc_traits::size_type size_type;	632	typedef typename __alloc_traits::size_type size_type;
705	#else	633	#else
706	typedef typename _NodeTypes::size_type size_type;	634	using size_type = size_t;
707	#endif	635	#endif
708	typedef typename _NodeTypes::difference_type difference_type;	636	using difference_type = ptrdiff_t;
709		637
710	public:	638	public:
711	// Create __node	639	// Create __node
712		640
713	typedef typename _NodeTypes::__node_type __node;	641	using __void_pointer _LIBCPP_NODEBUG = typename __alloc_traits::void_pointer;
714	typedef __rebind_alloc<__alloc_traits, __node> __node_allocator;	642
715	typedef allocator_traits<__node_allocator> __node_traits;	643	using __node _LIBCPP_NODEBUG = __hash_node<_Tp, __void_pointer>;
716	typedef typename _NodeTypes::__void_pointer __void_pointer;	644	using __node_allocator _LIBCPP_NODEBUG = __rebind_alloc<__alloc_traits, __node>;
717	typedef typename _NodeTypes::__node_pointer __node_pointer;	645	using __node_traits _LIBCPP_NODEBUG = allocator_traits<__node_allocator>;
718	typedef typename _NodeTypes::__node_pointer __node_const_pointer;	646	using __node_pointer _LIBCPP_NODEBUG = __rebind_pointer_t<__void_pointer, __node>;
719	typedef typename _NodeTypes::__node_base_type __first_node;	647
720	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;	648	using __first_node _LIBCPP_NODEBUG = __hash_node_base<__node_pointer>;
721	typedef typename _NodeTypes::__next_pointer __next_pointer;	649	using __node_base_pointer _LIBCPP_NODEBUG = __rebind_pointer_t<__void_pointer, __first_node>;
		650	using __next_pointer _LIBCPP_NODEBUG = __node_base_pointer;
722		651
723	private:	652	private:
724	// check for sane allocator pointer rebinding semantics. Rebinding the	653	// check for sane allocator pointer rebinding semantics. Rebinding the
...	@@ -747,6 +676,38 @@ private:	...	@@ -747,6 +676,38 @@ private:
747		676
748	_LIBCPP_HIDE_FROM_ABI size_type& size() _NOEXCEPT { return __size_; }	677	_LIBCPP_HIDE_FROM_ABI size_type& size() _NOEXCEPT { return __size_; }
749		678
		679	_LIBCPP_HIDE_FROM_ABI void
		680	__copy_construct(__next_pointer __other_iter, __next_pointer __own_iter, size_t __current_chash) {
		681	auto __bucket_count = bucket_count();
		682
		683	for (; __other_iter; __other_iter = __other_iter->__next_) {
		684	__node_holder __new_node = __construct_node_hash(__other_iter->__hash(), __other_iter->__upcast()->__get_value());
		685
		686	size_t __new_chash = std::__constrain_hash(__new_node->__hash(), __bucket_count);
		687	if (__new_chash != __current_chash) {
		688	__bucket_list_[__new_chash] = __own_iter;
		689	__current_chash = __new_chash;
		690	}
		691
		692	__own_iter->__next_ = static_cast<__next_pointer>(__new_node.release());
		693	__own_iter = __own_iter->__next_;
		694	}
		695	}
		696
		697	_LIBCPP_HIDE_FROM_ABI void __copy_construct(__next_pointer __other_iter) {
		698	__next_pointer __own_iter = __first_node_.__ptr();
		699	{
		700	__node_holder __new_node = __construct_node_hash(__other_iter->__hash(), __other_iter->__upcast()->__get_value());
		701	__own_iter->__next_ = static_cast<__next_pointer>(__new_node.release());
		702	}
		703
		704	size_t __current_chash = std::__constrain_hash(__own_iter->__next_->__hash(), bucket_count());
		705	__bucket_list_[__current_chash] = __own_iter;
		706	__other_iter = __other_iter->__next_;
		707	__own_iter = __own_iter->__next_;
		708	__copy_construct(__other_iter, __own_iter, __current_chash);
		709	}
		710
750	public:	711	public:
751	_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }	712	_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
752		713
...	@@ -811,40 +772,66 @@ public:	...	@@ -811,40 +772,66 @@ public:
811	_LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(__node_pointer __nd);	772	_LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(__node_pointer __nd);
812	_LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);	773	_LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
813		774
814	template <class _Key, class... _Args>
815	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_key_args(_Key const& __k, _Args&&... __args);
816
817	template <class... _Args>
818	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
819
820	template <class _Pp>
821	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Pp&& __x) {
822	return __emplace_unique_extract_key(std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>());
823	}
824
825	template <class _First,
826	class _Second,
827	__enable_if_t<__can_extract_map_key<_First, key_type, __container_value_type>::value, int> = 0>
828	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_First&& __f, _Second&& __s) {
829	return __emplace_unique_key_args(__f, std::forward<_First>(__f), std::forward<_Second>(__s));
830	}
831
832	template <class... _Args>	775	template <class... _Args>
833	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Args&&... __args) {	776	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Args&&... __args) {
834	return __emplace_unique_impl(std::forward<_Args>(__args)...);	777	return std::__try_key_extraction<key_type>(
835	}	778	[this](const key_type& __key, _Args&&... __args2) {
836		779	size_t __hash = hash_function()(__key);
837	template <class _Pp>	780	size_type __bc = bucket_count();
838	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {	781	bool __inserted = false;
839	return __emplace_unique_impl(std::forward<_Pp>(__x));	782	__next_pointer __nd;
840	}	783	size_t __chash;
841	template <class _Pp>	784	if (__bc != 0) {
842	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {	785	__chash = std::__constrain_hash(__hash, __bc);
843	return __emplace_unique_key_args(__x, std::forward<_Pp>(__x));	786	__nd = __bucket_list_[__chash];
844	}	787	if (__nd != nullptr) {
845	template <class _Pp>	788	for (__nd = __nd->__next_;
846	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {	789	__nd != nullptr &&
847	return __emplace_unique_key_args(__x.first, std::forward<_Pp>(__x));	790	(__nd->__hash() == __hash \|\| std::__constrain_hash(__nd->__hash(), __bc) == __chash);
		791	__nd = __nd->__next_) {
		792	if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __key))
		793	goto __done;
		794	}
		795	}
		796	}
		797	{
		798	__node_holder __h = __construct_node_hash(__hash, std::forward<_Args>(__args2)...);
		799	if (size() + 1 > __bc * max_load_factor()) {
		800	__rehash_unique(std::max<size_type>(2 * __bc + !std::__is_hash_power2(__bc),
		801	size_type(__math::ceil(float(size() + 1) / max_load_factor()))));
		802	__bc = bucket_count();
		803	__chash = std::__constrain_hash(__hash, __bc);
		804	}
		805	// insert_after __bucket_list_[__chash], or __first_node if bucket is null
		806	__next_pointer __pn = __bucket_list_[__chash];
		807	if (__pn == nullptr) {
		808	__pn = __first_node_.__ptr();
		809	__h->__next_ = __pn->__next_;
		810	__pn->__next_ = __h.get()->__ptr();
		811	// fix up __bucket_list_
		812	__bucket_list_[__chash] = __pn;
		813	if (__h->__next_ != nullptr)
		814	__bucket_list_[std::__constrain_hash(__h->__next_->__hash(), __bc)] = __h.get()->__ptr();
		815	} else {
		816	__h->__next_ = __pn->__next_;
		817	__pn->__next_ = static_cast<__next_pointer>(__h.get());
		818	}
		819	__nd = static_cast<__next_pointer>(__h.release());
		820	// increment size
		821	++size();
		822	__inserted = true;
		823	}
		824	__done:
		825	return pair<iterator, bool>(iterator(__nd), __inserted);
		826	},
		827	[this](_Args&&... __args2) {
		828	__node_holder __h = __construct_node(std::forward<_Args>(__args2)...);
		829	pair<iterator, bool> __r = __node_insert_unique(__h.get());
		830	if (__r.second)
		831	__h.release();
		832	return __r;
		833	},
		834	std::forward<_Args>(__args)...);
848	}	835	}
849		836
850	template <class... _Args>	837	template <class... _Args>
...	@@ -854,9 +841,7 @@ public:	...	@@ -854,9 +841,7 @@ public:
854		841
855	template <class _ValueT = _Tp, __enable_if_t<__is_hash_value_type<_ValueT>::value, int> = 0>	842	template <class _ValueT = _Tp, __enable_if_t<__is_hash_value_type<_ValueT>::value, int> = 0>
856	_LIBCPP_HIDE_FROM_ABI void __insert_unique_from_orphaned_node(value_type&& __value) {	843	_LIBCPP_HIDE_FROM_ABI void __insert_unique_from_orphaned_node(value_type&& __value) {
857	using __key_type = typename _NodeTypes::key_type;	844	__node_holder __h = __construct_node(const_cast<key_type&&>(__value.first), std::move(__value.second));
858
859	__node_holder __h = __construct_node(const_cast<__key_type&&>(__value.first), std::move(__value.second));
860	__node_insert_unique(__h.get());	845	__node_insert_unique(__h.get());
861	__h.release();	846	__h.release();
862	}	847	}
...	@@ -870,9 +855,7 @@ public:	...	@@ -870,9 +855,7 @@ public:
870		855
871	template <class _ValueT = _Tp, __enable_if_t<__is_hash_value_type<_ValueT>::value, int> = 0>	856	template <class _ValueT = _Tp, __enable_if_t<__is_hash_value_type<_ValueT>::value, int> = 0>
872	_LIBCPP_HIDE_FROM_ABI void __insert_multi_from_orphaned_node(value_type&& __value) {	857	_LIBCPP_HIDE_FROM_ABI void __insert_multi_from_orphaned_node(value_type&& __value) {
873	using __key_type = typename _NodeTypes::key_type;	858	__node_holder __h = __construct_node(const_cast<key_type&&>(__value.first), std::move(__value.second));
874
875	__node_holder __h = __construct_node(const_cast<__key_type&&>(__value.first), std::move(__value.second));
876	__node_insert_multi(__h.get());	859	__node_insert_multi(__h.get());
877	__h.release();	860	__h.release();
878	}	861	}
...	@@ -1017,8 +1000,8 @@ private:	...	@@ -1017,8 +1000,8 @@ private:
1017	template <class... _Args>	1000	template <class... _Args>
1018	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&&... __args);	1001	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&&... __args);
1019		1002
1020	template <class _First, class... _Rest>	1003	template <class... _Args>
1021	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest);	1004	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_hash(size_t __hash, _Args&&... __args);
1022		1005
1023	_LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __hash_table& __u) {	1006	_LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __hash_table& __u) {
1024	__copy_assign_alloc(__u, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());	1007	__copy_assign_alloc(__u, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());
...	@@ -1042,17 +1025,29 @@ private:	...	@@ -1042,17 +1025,29 @@ private:
1042	}	1025	}
1043	_LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}	1026	_LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
1044		1027
1045	_LIBCPP_HIDE_FROM_ABI void __deallocate_node(__next_pointer __np) _NOEXCEPT;	1028	_LIBCPP_HIDE_FROM_ABI void __deallocate_node(__node_pointer __nd) _NOEXCEPT {
		1029	auto& __alloc = __node_alloc();
		1030	__node_traits::destroy(__alloc, std::addressof(__nd->__get_value()));
		1031	std::__destroy_at(std::__to_address(__nd));
		1032	__node_traits::deallocate(__alloc, __nd, 1);
		1033	}
		1034
		1035	_LIBCPP_HIDE_FROM_ABI void __deallocate_node_list(__next_pointer __np) _NOEXCEPT {
		1036	while (__np != nullptr) {
		1037	__next_pointer __next = __np->__next_;
		1038	__deallocate_node(__np->__upcast());
		1039	__np = __next;
		1040	}
		1041	}
		1042
1046	_LIBCPP_HIDE_FROM_ABI __next_pointer __detach() _NOEXCEPT;	1043	_LIBCPP_HIDE_FROM_ABI __next_pointer __detach() _NOEXCEPT;
1047		1044
1048	template <class _From, class _ValueT = _Tp, __enable_if_t<__is_hash_value_type<_ValueT>::value, int> = 0>	1045	template <class _From, class _ValueT = _Tp, __enable_if_t<__is_hash_value_type<_ValueT>::value, int> = 0>
1049	_LIBCPP_HIDE_FROM_ABI void __assign_value(__get_hash_node_value_type_t<_Tp>& __lhs, _From&& __rhs) {	1046	_LIBCPP_HIDE_FROM_ABI void __assign_value(__get_hash_node_value_type_t<_Tp>& __lhs, _From&& __rhs) {
1050	using __key_type = typename _NodeTypes::key_type;
1051
1052	// This is technically UB, since the object was constructed as `const`.	1047	// This is technically UB, since the object was constructed as `const`.
1053	// Clang doesn't optimize on this currently though.	1048	// Clang doesn't optimize on this currently though.
1054	const_cast<__key_type&>(__lhs.first) = const_cast<__copy_cvref_t<_From, __key_type>&&>(__rhs.first);	1049	const_cast<key_type&>(__lhs.first) = const_cast<__copy_cvref_t<_From, key_type>&&>(__rhs.first);
1055	__lhs.second = std::forward<_From>(__rhs).second;	1050	__lhs.second = std::forward<_From>(__rhs).second;
1056	}	1051	}
1057		1052
1058	template <class _From, class _ValueT = _Tp, __enable_if_t<!__is_hash_value_type<_ValueT>::value, int> = 0>	1053	template <class _From, class _ValueT = _Tp, __enable_if_t<!__is_hash_value_type<_ValueT>::value, int> = 0>
...	@@ -1101,16 +1096,29 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a	...	@@ -1101,16 +1096,29 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const allocator_type& __a
1101	__max_load_factor_(1.0f) {}	1096	__max_load_factor_(1.0f) {}
1102		1097
1103	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1098	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1104	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u)	1099	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __other)
1105	: __bucket_list_(nullptr,	1100	: __bucket_list_(nullptr,
1106	__bucket_list_deleter(allocator_traits<__pointer_allocator>::select_on_container_copy_construction(	1101	__bucket_list_deleter(__pointer_alloc_traits::select_on_container_copy_construction(
1107	__u.__bucket_list_.get_deleter().__alloc()),	1102	__other.__bucket_list_.get_deleter().__alloc()),
1108	0)),	1103	0)),
1109	__node_alloc_(allocator_traits<__node_allocator>::select_on_container_copy_construction(__u.__node_alloc())),	1104	__node_alloc_(__node_traits::select_on_container_copy_construction(__other.__node_alloc())),
1110	__size_(0),	1105	__size_(0),
1111	__hasher_(__u.hash_function()),	1106	__hasher_(__other.hash_function()),
1112	__max_load_factor_(__u.__max_load_factor_),	1107	__max_load_factor_(__other.__max_load_factor_),
1113	__key_eq_(__u.__key_eq_) {}	1108	__key_eq_(__other.__key_eq_) {
		1109	if (__other.size() == 0)
		1110	return;
		1111
		1112	auto& __bucket_list_del = __bucket_list_.get_deleter();
		1113	auto __bucket_count = __other.bucket_count();
		1114	__bucket_list_.reset(__pointer_alloc_traits::allocate(__bucket_list_del.__alloc(), __bucket_count));
		1115	__bucket_list_del.size() = __bucket_count;
		1116
		1117	std::fill_n(__bucket_list_.get(), __bucket_count, nullptr);
		1118
		1119	__copy_construct(__other.__first_node_.__next_);
		1120	__size_ = __other.size();
		1121	}
1114		1122
1115	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1123	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1116	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u, const allocator_type& __a)	1124	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u, const allocator_type& __a)
...	@@ -1169,7 +1177,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table() {	...	@@ -1169,7 +1177,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::~__hash_table() {
1169	static_assert(is_copy_constructible<hasher>::value, "Hasher must be copy-constructible.");	1177	static_assert(is_copy_constructible<hasher>::value, "Hasher must be copy-constructible.");
1170	#endif	1178	#endif
1171		1179
1172	__deallocate_node(__first_node_.__next_);	1180	__deallocate_node_list(__first_node_.__next_);
1173	}	1181	}
1174		1182
1175	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1183	template <class _Tp, class _Hash, class _Equal, class _Alloc>
...	@@ -1184,28 +1192,76 @@ void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(const __hash_	...	@@ -1184,28 +1192,76 @@ void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__copy_assign_alloc(const __hash_
1184	}	1192	}
1185		1193
1186	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1194	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1187	__hash_table<_Tp, _Hash, _Equal, _Alloc>& __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u) {	1195	__hash_table<_Tp, _Hash, _Equal, _Alloc>&
1188	if (this != std::addressof(__u)) {	1196	__hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __other) {
1189	__copy_assign_alloc(__u);	1197	if (this == std::addressof(__other))
1190	hash_function() = __u.hash_function();	1198	return *this;
1191	key_eq() = __u.key_eq();	1199
1192	max_load_factor() = __u.max_load_factor();	1200	__copy_assign_alloc(__other);
1193	__assign_multi(__u.begin(), __u.end());	1201	hash_function() = __other.hash_function();
		1202	key_eq() = __other.key_eq();
		1203	max_load_factor() = __other.max_load_factor();
		1204
		1205	if (__other.size() == 0) {
		1206	clear();
		1207	return *this;
1194	}	1208	}
1195	return *this;
1196	}
1197		1209
1198	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1210	auto __bucket_count = __other.bucket_count();
1199	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate_node(__next_pointer __np) _NOEXCEPT {	1211	if (__bucket_count != bucket_count()) {
1200	__node_allocator& __na = __node_alloc();	1212	auto& __bucket_list_del = __bucket_list_.get_deleter();
1201	while (__np != nullptr) {	1213	__bucket_list_.reset(__pointer_alloc_traits::allocate(__bucket_list_del.__alloc(), __bucket_count));
1202	__next_pointer __next = __np->__next_;	1214	__bucket_list_del.size() = __bucket_count;
1203	__node_pointer __real_np = __np->__upcast();	1215	}
1204	__node_traits::destroy(__na, _NodeTypes::__get_ptr(__real_np->__get_value()));	1216	std::fill_n(__bucket_list_.get(), __bucket_count, nullptr);
1205	std::__destroy_at(std::addressof(*__real_np));	1217
1206	__node_traits::deallocate(__na, __real_np, 1);	1218	if (!__first_node_.__next_) {
1207	__np = __next;	1219	__copy_construct(__other.__first_node_.__next_);
		1220	__size_ = __other.size();
		1221	return *this;
		1222	}
		1223
		1224	__next_pointer __other_iter = __other.__first_node_.__next_;
		1225	__next_pointer __own_iter = __first_node_.__ptr();
		1226	{
		1227	__node_pointer __next = __own_iter->__next_->__upcast();
		1228	__assign_value(__next->__get_value(), __other_iter->__upcast()->__get_value());
		1229	__next->__hash_ = __other_iter->__hash();
		1230	}
		1231	size_t __current_chash = std::__constrain_hash(__own_iter->__next_->__hash(), __bucket_count);
		1232	__bucket_list_[__current_chash] = __own_iter;
		1233	__other_iter = __other_iter->__next_;
		1234	__own_iter = __own_iter->__next_;
		1235
		1236	// Go through the nodes of the incoming hash table and copy then into the destination hash table, reusing as many
		1237	// existing nodes as posssible in the destination.
		1238	while (__other_iter && __own_iter->__next_) {
		1239	__node_pointer __next = __own_iter->__next_->__upcast();
		1240	__assign_value(__next->__get_value(), __other_iter->__upcast()->__get_value());
		1241	__next->__hash_ = __other_iter->__hash();
		1242
		1243	size_t __new_chash = std::__constrain_hash(__next->__hash_, __bucket_count);
		1244	if (__new_chash != __current_chash) {
		1245	__bucket_list_[__new_chash] = __own_iter;
		1246	__current_chash = __new_chash;
		1247	}
		1248
		1249	__other_iter = __other_iter->__next_;
		1250	__own_iter = __own_iter->__next_;
1208	}	1251	}
		1252
		1253	// At this point we either have consumed the whole incoming hash table, or we don't have any more nodes to reuse in
		1254	// the destination. Either continue with constructing new nodes, or deallocate the left over nodes.
		1255	if (__own_iter->__next_) {
		1256	__deallocate_node_list(__own_iter->__next_);
		1257	__own_iter->__next_ = nullptr;
		1258	} else {
		1259	__copy_construct(__other_iter, __own_iter, __current_chash);
		1260	}
		1261
		1262	__size_ = __other.size();
		1263
		1264	return *this;
1209	}	1265	}
1210		1266
1211	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1267	template <class _Tp, class _Hash, class _Equal, class _Alloc>
...	@@ -1251,23 +1307,14 @@ void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(__hash_table& __u,	...	@@ -1251,23 +1307,14 @@ void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(__hash_table& __u,
1251	max_load_factor() = __u.max_load_factor();	1307	max_load_factor() = __u.max_load_factor();
1252	if (bucket_count() != 0) {	1308	if (bucket_count() != 0) {
1253	__next_pointer __cache = __detach();	1309	__next_pointer __cache = __detach();
1254	#if _LIBCPP_HAS_EXCEPTIONS	1310	auto __guard = std::__make_scope_guard([&] { __deallocate_node_list(__cache); });
1255	try {	1311	const_iterator __i = __u.begin();
1256	#endif // _LIBCPP_HAS_EXCEPTIONS	1312	while (__cache != nullptr && __u.size() != 0) {
1257	const_iterator __i = __u.begin();	1313	__assign_value(__cache->__upcast()->__get_value(), std::move(__u.remove(__i++)->__get_value()));
1258	while (__cache != nullptr && __u.size() != 0) {	1314	__next_pointer __next = __cache->__next_;
1259	__assign_value(__cache->__upcast()->__get_value(), std::move(__u.remove(__i++)->__get_value()));	1315	__node_insert_multi(__cache->__upcast());
1260	__next_pointer __next = __cache->__next_;	1316	__cache = __next;
1261	__node_insert_multi(__cache->__upcast());
1262	__cache = __next;
1263	}
1264	#if _LIBCPP_HAS_EXCEPTIONS
1265	} catch (...) {
1266	__deallocate_node(__cache);
1267	throw;
1268	}	1317	}
1269	#endif // _LIBCPP_HAS_EXCEPTIONS
1270	__deallocate_node(__cache);
1271	}	1318	}
1272	const_iterator __i = __u.begin();	1319	const_iterator __i = __u.begin();
1273	while (__u.size() != 0)	1320	while (__u.size() != 0)
...	@@ -1290,27 +1337,18 @@ template <class _InputIterator>	...	@@ -1290,27 +1337,18 @@ template <class _InputIterator>
1290	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first, _InputIterator __last) {	1337	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_unique(_InputIterator __first, _InputIterator __last) {
1291	typedef iterator_traits<_InputIterator> _ITraits;	1338	typedef iterator_traits<_InputIterator> _ITraits;
1292	typedef typename _ITraits::value_type _ItValueType;	1339	typedef typename _ITraits::value_type _ItValueType;
1293	static_assert(is_same<_ItValueType, __container_value_type>::value,	1340	static_assert(
1294	"__assign_unique may only be called with the containers value type");	1341	is_same<_ItValueType, value_type>::value, "__assign_unique may only be called with the containers value type");
1295		1342
1296	if (bucket_count() != 0) {	1343	if (bucket_count() != 0) {
1297	__next_pointer __cache = __detach();	1344	__next_pointer __cache = __detach();
1298	#if _LIBCPP_HAS_EXCEPTIONS	1345	auto __guard = std::__make_scope_guard([&] { __deallocate_node_list(__cache); });
1299	try {	1346	for (; __cache != nullptr && __first != __last; ++__first) {
1300	#endif // _LIBCPP_HAS_EXCEPTIONS	1347	__assign_value(__cache->__upcast()->__get_value(), *__first);
1301	for (; __cache != nullptr && __first != __last; ++__first) {	1348	__next_pointer __next = __cache->__next_;
1302	__assign_value(__cache->__upcast()->__get_value(), *__first);	1349	__node_insert_unique(__cache->__upcast());
1303	__next_pointer __next = __cache->__next_;	1350	__cache = __next;
1304	__node_insert_unique(__cache->__upcast());
1305	__cache = __next;
1306	}
1307	#if _LIBCPP_HAS_EXCEPTIONS
1308	} catch (...) {
1309	__deallocate_node(__cache);
1310	throw;
1311	}	1351	}
1312	#endif // _LIBCPP_HAS_EXCEPTIONS
1313	__deallocate_node(__cache);
1314	}	1352	}
1315	for (; __first != __last; ++__first)	1353	for (; __first != __last; ++__first)
1316	__emplace_unique(*__first);	1354	__emplace_unique(*__first);
...	@@ -1321,31 +1359,20 @@ template <class _InputIterator>	...	@@ -1321,31 +1359,20 @@ template <class _InputIterator>
1321	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first, _InputIterator __last) {	1359	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first, _InputIterator __last) {
1322	typedef iterator_traits<_InputIterator> _ITraits;	1360	typedef iterator_traits<_InputIterator> _ITraits;
1323	typedef typename _ITraits::value_type _ItValueType;	1361	typedef typename _ITraits::value_type _ItValueType;
1324	static_assert(	1362	static_assert(is_same<_ItValueType, value_type>::value,
1325	(is_same<_ItValueType, __container_value_type>::value \|\| is_same<_ItValueType, __node_value_type>::value),	1363	"__assign_multi may only be called with the containers value type or the nodes value type");
1326	"__assign_multi may only be called with the containers value type"
1327	" or the nodes value type");
1328	if (bucket_count() != 0) {	1364	if (bucket_count() != 0) {
1329	__next_pointer __cache = __detach();	1365	__next_pointer __cache = __detach();
1330	#if _LIBCPP_HAS_EXCEPTIONS	1366	auto __guard = std::__make_scope_guard([&] { __deallocate_node_list(__cache); });
1331	try {	1367	for (; __cache != nullptr && __first != __last; ++__first) {
1332	#endif // _LIBCPP_HAS_EXCEPTIONS	1368	__assign_value(__cache->__upcast()->__get_value(), *__first);
1333	for (; __cache != nullptr && __first != __last; ++__first) {	1369	__next_pointer __next = __cache->__next_;
1334	__assign_value(__cache->__upcast()->__get_value(), *__first);	1370	__node_insert_multi(__cache->__upcast());
1335	__next_pointer __next = __cache->__next_;	1371	__cache = __next;
1336	__node_insert_multi(__cache->__upcast());
1337	__cache = __next;
1338	}
1339	#if _LIBCPP_HAS_EXCEPTIONS
1340	} catch (...) {
1341	__deallocate_node(__cache);
1342	throw;
1343	}	1372	}
1344	#endif // _LIBCPP_HAS_EXCEPTIONS
1345	__deallocate_node(__cache);
1346	}	1373	}
1347	for (; __first != __last; ++__first)	1374	for (; __first != __last; ++__first)
1348	__emplace_multi(_NodeTypes::__get_value(*__first));	1375	__emplace_multi(*__first);
1349	}	1376	}
1350		1377
1351	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1378	template <class _Tp, class _Hash, class _Equal, class _Alloc>
...	@@ -1375,7 +1402,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT {	...	@@ -1375,7 +1402,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT {
1375	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1402	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1376	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT {	1403	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT {
1377	if (size() > 0) {	1404	if (size() > 0) {
1378	__deallocate_node(__first_node_.__next_);	1405	__deallocate_node_list(__first_node_.__next_);
1379	__first_node_.__next_ = nullptr;	1406	__first_node_.__next_ = nullptr;
1380	size_type __bc = bucket_count();	1407	size_type __bc = bucket_count();
1381	for (size_type __i = 0; __i < __bc; ++__i)	1408	for (size_type __i = 0; __i < __bc; ++__i)
...	@@ -1561,69 +1588,6 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(const_iterator __p	...	@@ -1561,69 +1588,6 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(const_iterator __p
1561	return __node_insert_multi(__cp);	1588	return __node_insert_multi(__cp);
1562	}	1589	}
1563		1590
1564	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1565	template <class _Key, class... _Args>
1566	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
1567	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) {
1568	size_t __hash = hash_function()(__k);
1569	size_type __bc = bucket_count();
1570	bool __inserted = false;
1571	__next_pointer __nd;
1572	size_t __chash;
1573	if (__bc != 0) {
1574	__chash = std::__constrain_hash(__hash, __bc);
1575	__nd = __bucket_list_[__chash];
1576	if (__nd != nullptr) {
1577	for (__nd = __nd->__next_;
1578	__nd != nullptr && (__nd->__hash() == __hash \|\| std::__constrain_hash(__nd->__hash(), __bc) == __chash);
1579	__nd = __nd->__next_) {
1580	if ((__nd->__hash() == __hash) && key_eq()(__nd->__upcast()->__get_value(), __k))
1581	goto __done;
1582	}
1583	}
1584	}
1585	{
1586	__node_holder __h = __construct_node_hash(__hash, std::forward<_Args>(__args)...);
1587	if (size() + 1 > __bc * max_load_factor() \|\| __bc == 0) {
1588	__rehash_unique(std::max<size_type>(
1589	2 * __bc + !std::__is_hash_power2(__bc), size_type(__math::ceil(float(size() + 1) / max_load_factor()))));
1590	__bc = bucket_count();
1591	__chash = std::__constrain_hash(__hash, __bc);
1592	}
1593	// insert_after __bucket_list_[__chash], or __first_node if bucket is null
1594	__next_pointer __pn = __bucket_list_[__chash];
1595	if (__pn == nullptr) {
1596	__pn = __first_node_.__ptr();
1597	__h->__next_ = __pn->__next_;
1598	__pn->__next_ = __h.get()->__ptr();
1599	// fix up __bucket_list_
1600	__bucket_list_[__chash] = __pn;
1601	if (__h->__next_ != nullptr)
1602	__bucket_list_[std::__constrain_hash(__h->__next_->__hash(), __bc)] = __h.get()->__ptr();
1603	} else {
1604	__h->__next_ = __pn->__next_;
1605	__pn->__next_ = static_cast<__next_pointer>(__h.get());
1606	}
1607	__nd = static_cast<__next_pointer>(__h.release());
1608	// increment size
1609	++size();
1610	__inserted = true;
1611	}
1612	__done:
1613	return pair<iterator, bool>(iterator(__nd), __inserted);
1614	}
1615
1616	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1617	template <class... _Args>
1618	pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
1619	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique_impl(_Args&&... __args) {
1620	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1621	pair<iterator, bool> __r = __node_insert_unique(__h.get());
1622	if (__r.second)
1623	__h.release();
1624	return __r;
1625	}
1626
1627	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1591	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1628	template <class... _Args>	1592	template <class... _Args>
1629	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator	1593	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
...	@@ -1764,41 +1728,45 @@ void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n) _LIBCPP_D	...	@@ -1764,41 +1728,45 @@ void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __n) _LIBCPP_D
1764		1728
1765	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1729	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1766	template <bool _UniqueKeys>	1730	template <bool _UniqueKeys>
1767	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__do_rehash(size_type __nbc) {	1731	void __hash_table<_Tp, _Hash, _Equal, _Alloc>::__do_rehash(size_type __bucket_count) {
1768	__pointer_allocator& __npa = __bucket_list_.get_deleter().__alloc();	1732	__pointer_allocator& __ptr_alloc = __bucket_list_.get_deleter().__alloc();
1769	__bucket_list_.reset(__nbc > 0 ? __pointer_alloc_traits::allocate(__npa, __nbc) : nullptr);	1733	__bucket_list_.reset(__bucket_count > 0 ? __pointer_alloc_traits::allocate(__ptr_alloc, __bucket_count) : nullptr);
1770	__bucket_list_.get_deleter().size() = __nbc;	1734	__bucket_list_.get_deleter().size() = __bucket_count;
1771	if (__nbc > 0) {	1735
1772	for (size_type __i = 0; __i < __nbc; ++__i)	1736	if (__bucket_count == 0)
1773	__bucket_list_[__i] = nullptr;	1737	return;
1774	__next_pointer __pp = __first_node_.__ptr();	1738
1775	__next_pointer __cp = __pp->__next_;	1739	for (size_type __i = 0; __i < __bucket_count; ++__i)
1776	if (__cp != nullptr) {	1740	__bucket_list_[__i] = nullptr;
1777	size_type __chash = std::__constrain_hash(__cp->__hash(), __nbc);	1741	__next_pointer __pp = __first_node_.__ptr();
1778	__bucket_list_[__chash] = __pp;	1742	__next_pointer __cp = __pp->__next_;
1779	size_type __phash = __chash;	1743
1780	for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) {	1744	if (!__cp)
1781	__chash = std::__constrain_hash(__cp->__hash(), __nbc);	1745	return;
1782	if (__chash == __phash)	1746
1783	__pp = __cp;	1747	size_type __chash = std::__constrain_hash(__cp->__hash(), __bucket_count);
1784	else {	1748	__bucket_list_[__chash] = __pp;
1785	if (__bucket_list_[__chash] == nullptr) {	1749	size_type __phash = __chash;
1786	__bucket_list_[__chash] = __pp;	1750	for (__pp = __cp, void(), __cp = __cp->__next_; __cp != nullptr; __cp = __pp->__next_) {
1787	__pp = __cp;	1751	__chash = std::__constrain_hash(__cp->__hash(), __bucket_count);
1788	__phash = __chash;	1752	if (__chash == __phash)
1789	} else {	1753	__pp = __cp;
1790	__next_pointer __np = __cp;	1754	else {
1791	if _LIBCPP_CONSTEXPR_SINCE_CXX17 (!_UniqueKeys) {	1755	if (__bucket_list_[__chash] == nullptr) {
1792	for (; __np->__next_ != nullptr &&	1756	__bucket_list_[__chash] = __pp;
1793	key_eq()(__cp->__upcast()->__get_value(), __np->__next_->__upcast()->__get_value());	1757	__pp = __cp;
1794	__np = __np->__next_)	1758	__phash = __chash;
1795	;	1759	} else {
1796	}	1760	__next_pointer __np = __cp;
1797	__pp->__next_ = __np->__next_;	1761	if _LIBCPP_CONSTEXPR (!_UniqueKeys) {
1798	__np->__next_ = __bucket_list_[__chash]->__next_;	1762	for (; __np->__next_ != nullptr &&
1799	__bucket_list_[__chash]->__next_ = __cp;	1763	key_eq()(__cp->__upcast()->__get_value(), __np->__next_->__upcast()->__get_value());
1800	}	1764	__np = __np->__next_)
		1765	;
1801	}	1766	}
		1767	__pp->__next_ = __np->__next_;
		1768	__np->__next_ = __bucket_list_[__chash]->__next_;
		1769	__bucket_list_[__chash]->__next_ = __cp;
1802	}	1770	}
1803	}	1771	}
1804	}	1772	}
...	@@ -1854,16 +1822,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&&... __args) {	...	@@ -1854,16 +1822,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&&... __args) {
1854	__node_allocator& __na = __node_alloc();	1822	__node_allocator& __na = __node_alloc();
1855	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));	1823	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
1856		1824
1857	// Begin the lifetime of the node itself. Note that this doesn't begin the lifetime of the value	1825	// Begin the lifetime of the node itself and the value_type contained within.
1858	// held inside the node, since we need to use the allocator's construct() method for that.
1859	//	1826	//
1860	// We don't use the allocator's construct() method to construct the node itself since the	1827	// We don't use the allocator's construct() method to construct the node itself since the
1861	// Cpp17FooInsertable named requirements don't require the allocator's construct() method	1828	// Cpp17FooInsertable named requirements don't require the allocator's construct() method
1862	// to work on anything other than the value_type.	1829	// to work on anything other than the value_type.
1863	std::__construct_at(std::addressof(__h), / next = / nullptr, / hash = */ 0);	1830	std::__construct_at(std::addressof(__h), / hash = */ 0, __na, std::forward<_Args>(__args)...);
1864		1831
1865	// Now construct the value_type using the allocator's construct() method.
1866	__node_traits::construct(__na, _NodeTypes::__get_ptr(__h->__get_value()), std::forward<_Args>(__args)...);
1867	__h.get_deleter().__value_constructed = true;	1832	__h.get_deleter().__value_constructed = true;
1868		1833
1869	__h->__hash_ = hash_function()(__h->__get_value());	1834	__h->__hash_ = hash_function()(__h->__get_value());
...	@@ -1871,15 +1836,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&&... __args) {	...	@@ -1871,15 +1836,13 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&&... __args) {
1871	}	1836	}
1872		1837
1873	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1838	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1874	template <class _First, class... _Rest>	1839	template <class... _Args>
1875	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder	1840	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
1876	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(size_t __hash, _First&& __f, _Rest&&... __rest) {	1841	__hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node_hash(size_t __hash, _Args&&... __args) {
1877	static_assert(!__is_hash_value_type<_First, _Rest...>::value, "Construct cannot be called with a hash value type");	1842	static_assert(!__is_hash_value_type<_Args...>::value, "Construct cannot be called with a hash value type");
1878	__node_allocator& __na = __node_alloc();	1843	__node_allocator& __na = __node_alloc();
1879	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));	1844	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
1880	std::__construct_at(std::addressof(__h), / next = / nullptr, / hash = */ __hash);	1845	std::__construct_at(std::addressof(__h), / hash = */ __hash, __na, std::forward<_Args>(__args)...);
1881	__node_traits::construct(
1882	__na, _NodeTypes::__get_ptr(__h->__get_value()), std::forward<_First>(__f), std::forward<_Rest>(__rest)...);
1883	__h.get_deleter().__value_constructed = true;	1846	__h.get_deleter().__value_constructed = true;
1884	return __h;	1847	return __h;
1885	}	1848	}
...	@@ -1899,12 +1862,63 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p) {	...	@@ -1899,12 +1862,63 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __p) {
1899	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1862	template <class _Tp, class _Hash, class _Equal, class _Alloc>
1900	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator	1863	typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
1901	__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __first, const_iterator __last) {	1864	__hash_table<_Tp, _Hash, _Equal, _Alloc>::erase(const_iterator __first, const_iterator __last) {
1902	for (const_iterator __p = __first; __first != __last; __p = __first) {	1865	if (__first == __last)
1903	++__first;	1866	return iterator(__last.__node_);
1904	erase(__p);	1867
		1868	// current node
		1869	__next_pointer __current = __first.__node_;
		1870	size_type __bucket_count = bucket_count();
		1871	size_t __chash = std::__constrain_hash(__current->__hash(), __bucket_count);
		1872	// find previous node
		1873	__next_pointer __before_first = __bucket_list_[__chash];
		1874	for (; __before_first->__next_ != __current; __before_first = __before_first->__next_)
		1875	;
		1876
		1877	__next_pointer __last_node = __last.__node_;
		1878
		1879	// If __before_first is in the same bucket (i.e. the first element we erase is not the first in the bucket), clear
		1880	// this bucket first without re-linking it
		1881	if (__before_first != __first_node_.__ptr() &&
		1882	std::__constrain_hash(__before_first->__hash(), __bucket_count) == __chash) {
		1883	while (__current != __last_node) {
		1884	auto __next = __current->__next_;
		1885	__deallocate_node(__current->__upcast());
		1886	__current = __next;
		1887	--__size_;
		1888
		1889	if (__next) {
		1890	if (auto __next_chash = std::__constrain_hash(__next->__hash(), __bucket_count); __next_chash != __chash) {
		1891	__bucket_list_[__next_chash] = __before_first;
		1892	__chash = __next_chash;
		1893	break;
		1894	}
		1895	}
		1896	}
1905	}	1897	}
1906	__next_pointer __np = __last.__node_;	1898
1907	return iterator(__np);	1899	while (__current != __last_node) {
		1900	auto __next = __current->__next_;
		1901	__deallocate_node(__current->__upcast());
		1902	__current = __next;
		1903	--__size_;
		1904
		1905	// When switching buckets, set the old bucket to be empty and update the next bucket to have __before_first as its
		1906	// before-first element
		1907	if (__next) {
		1908	if (auto __next_chash = std::__constrain_hash(__next->__hash(), __bucket_count); __next_chash != __chash) {
		1909	__bucket_list_[__chash] = nullptr;
		1910	__bucket_list_[__next_chash] = __before_first;
		1911	__chash = __next_chash;
		1912	}
		1913	} else { // When __next is a nullptr we've fully erased the last bucket. Update the bucket list accordingly.
		1914	__bucket_list_[__chash] = nullptr;
		1915	}
		1916	}
		1917
		1918	// re-link __before_first with __last
		1919	__before_first->__next_ = __current;
		1920
		1921	return iterator(__last.__node_);
1908	}	1922	}
1909		1923
1910	template <class _Tp, class _Hash, class _Equal, class _Alloc>	1924	template <class _Tp, class _Hash, class _Equal, class _Alloc>

lib/libcxx/include/__ios/fpos.h+4-4

...	@@ -30,7 +30,7 @@ public:	...	@@ -30,7 +30,7 @@ public:
30		30
31	_LIBCPP_HIDE_FROM_ABI operator streamoff() const { return __off_; }	31	_LIBCPP_HIDE_FROM_ABI operator streamoff() const { return __off_; }
32		32
33	_LIBCPP_HIDE_FROM_ABI _StateT state() const { return __st_; }	33	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _StateT state() const { return __st_; }
34	_LIBCPP_HIDE_FROM_ABI void state(_StateT __st) { __st_ = __st; }	34	_LIBCPP_HIDE_FROM_ABI void state(_StateT __st) { __st_ = __st; }
35		35
36	_LIBCPP_HIDE_FROM_ABI fpos& operator+=(streamoff __off) {	36	_LIBCPP_HIDE_FROM_ABI fpos& operator+=(streamoff __off) {
...	@@ -38,7 +38,7 @@ public:	...	@@ -38,7 +38,7 @@ public:
38	return *this;	38	return *this;
39	}	39	}
40		40
41	_LIBCPP_HIDE_FROM_ABI fpos operator+(streamoff __off) const {	41	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI fpos operator+(streamoff __off) const {
42	fpos __t(*this);	42	fpos __t(*this);
43	__t += __off;	43	__t += __off;
44	return __t;	44	return __t;
...	@@ -49,7 +49,7 @@ public:	...	@@ -49,7 +49,7 @@ public:
49	return *this;	49	return *this;
50	}	50	}
51		51
52	_LIBCPP_HIDE_FROM_ABI fpos operator-(streamoff __off) const {	52	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI fpos operator-(streamoff __off) const {
53	fpos __t(*this);	53	fpos __t(*this);
54	__t -= __off;	54	__t -= __off;
55	return __t;	55	return __t;
...	@@ -57,7 +57,7 @@ public:	...	@@ -57,7 +57,7 @@ public:
57	};	57	};
58		58
59	template <class _StateT>	59	template <class _StateT>
60	inline _LIBCPP_HIDE_FROM_ABI streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {	60	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI streamoff operator-(const fpos<_StateT>& __x, const fpos<_StateT>& __y) {
61	return streamoff(__x) - streamoff(__y);	61	return streamoff(__x) - streamoff(__y);
62	}	62	}
63		63

lib/libcxx/include/__iterator/back_insert_iterator.h+1-7

 @@ -26,15 +26,9 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Container>
 class back_insert_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<back_insert_iterator<_Container>, output_iterator_tag, void, void, void, void> {
-    : public iterator<output_iterator_tag, void, void, void, void>
-#endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
   _Container* container;

lib/libcxx/include/__iterator/bounded_iter.h+7-8

 @@ -74,12 +74,12 @@ struct __bounded_iter {
   _LIBCPP_HIDE_FROM_ABI __bounded_iter(__bounded_iter const&) = default;
   _LIBCPP_HIDE_FROM_ABI __bounded_iter(__bounded_iter&&)      = default;
-  template < class _OtherIterator,
+  template <class _OtherIterator,
-             __enable_if_t<
+            __enable_if_t<
-                 _And< is_convertible<const _OtherIterator&, _Iterator>,
+                _And<is_convertible<const _OtherIterator&, _Iterator>,
-                       _Or<is_same<reference, __iter_reference<_OtherIterator> >,
+                     _Or<is_same<reference, __iterator_reference<_OtherIterator> >,
-                           is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIterator> > > > >::value,
+                         is_same<reference, __make_const_lvalue_ref<__iterator_reference<_OtherIterator> > > > >::value,
-                 int> = 0>
+                int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __bounded_iter(__bounded_iter<_OtherIterator> const& __other) _NOEXCEPT
       : __current_(__other.__current_),
         __begin_(__other.__begin_),
 @@ -116,8 +116,7 @@ public:
   // These operations check that the iterator is dereferenceable. Since the class invariant is
   // that the iterator is always within `[begin, end]`, we only need to check it's not pointing to
   // `end`. This is easier for the optimizer because it aligns with the `iter != container.end()`
-  // checks that typical callers already use (see
+  // checks that typical callers already use (see https://llvm.org/PR78829).
-  // https://github.com/llvm/llvm-project/issues/78829).
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
         __current_ != __end_, "__bounded_iter::operator*: Attempt to dereference an iterator at the end");

lib/libcxx/include/__iterator/concepts.h+6-9

...	@@ -117,15 +117,12 @@ template <class _Tp>	...	@@ -117,15 +117,12 @@ template <class _Tp>
117	concept __signed_integer_like = signed_integral<_Tp>;	117	concept __signed_integer_like = signed_integral<_Tp>;
118		118
119	template <class _Ip>	119	template <class _Ip>
120	concept weakly_incrementable =	120	concept weakly_incrementable = movable<_Ip> && requires(_Ip __i) {
121	// TODO: remove this once the clang bug is fixed (bugs.llvm.org/PR48173).	121	typename iter_difference_t<_Ip>;
122	!same_as<_Ip, bool> && // Currently, clang does not handle bool correctly.	122	requires __signed_integer_like<iter_difference_t<_Ip>>;
123	movable<_Ip> && requires(_Ip __i) {	123	{ ++__i } -> same_as<_Ip&>; // not required to be equality-preserving
124	typename iter_difference_t<_Ip>;	124	__i++; // not required to be equality-preserving
125	requires __signed_integer_like<iter_difference_t<_Ip>>;	125	};
126	{ ++__i } -> same_as<_Ip&>; // not required to be equality-preserving
127	__i++; // not required to be equality-preserving
128	};
129		126
130	// [iterator.concept.inc]	127	// [iterator.concept.inc]
131	template <class _Ip>	128	template <class _Ip>

lib/libcxx/include/__iterator/cpp17_iterator_concepts.h+13-12

 @@ -68,7 +68,8 @@ concept __cpp17_default_constructible = is_default_constructible_v<_Tp>;
 template <class _Iter>
 concept __cpp17_iterator =
     __cpp17_copy_constructible<_Iter> && __cpp17_copy_assignable<_Iter> && __cpp17_destructible<_Iter> &&
-    (is_signed_v<__iter_diff_t<_Iter>> || is_void_v<__iter_diff_t<_Iter>>) && requires(_Iter __iter) {
+    (is_signed_v<__iterator_difference_type<_Iter>> || is_void_v<__iterator_difference_type<_Iter>>) &&
+    requires(_Iter __iter) {
       { *__iter };
       { ++__iter } -> same_as<_Iter&>;
     };
 @@ -81,8 +82,8 @@ concept __cpp17_input_iterator =
       { __lhs != std::as_const(__rhs) } -> __boolean_testable;
       { std::as_const(__lhs) != std::as_const(__rhs) } -> __boolean_testable;
-      { *__lhs } -> same_as<__iter_reference<_Iter>>;
+      { *__lhs } -> same_as<__iterator_reference<_Iter>>;
-      { *std::as_const(__lhs) } -> same_as<__iter_reference<_Iter>>;
+      { *std::as_const(__lhs) } -> same_as<__iterator_reference<_Iter>>;
       { ++__lhs } -> same_as<_Iter&>;
       { (void)__lhs++ };
 @@ -101,19 +102,19 @@ template <class _Iter>
 concept __cpp17_forward_iterator =
     __cpp17_input_iterator<_Iter> && __cpp17_default_constructible<_Iter> && requires(_Iter __iter) {
       { __iter++ } -> convertible_to<const _Iter&>;
-      { *__iter++ } -> same_as<__iter_reference<_Iter>>;
+      { *__iter++ } -> same_as<__iterator_reference<_Iter>>;
     };
 template <class _Iter>
 concept __cpp17_bidirectional_iterator = __cpp17_forward_iterator<_Iter> && requires(_Iter __iter) {
   { --__iter } -> same_as<_Iter&>;
   { __iter-- } -> convertible_to<const _Iter&>;
-  { *__iter-- } -> same_as<__iter_reference<_Iter>>;
+  { *__iter-- } -> same_as<__iterator_reference<_Iter>>;
 };
 template <class _Iter>
 concept __cpp17_random_access_iterator =
-    __cpp17_bidirectional_iterator<_Iter> && requires(_Iter __iter, __iter_diff_t<_Iter> __n) {
+    __cpp17_bidirectional_iterator<_Iter> && requires(_Iter __iter, __iterator_difference_type<_Iter> __n) {
       { __iter += __n } -> same_as<_Iter&>;
       { __iter + __n } -> same_as<_Iter>;
 @@ -125,13 +126,13 @@ concept __cpp17_random_access_iterator =
       { __iter - __n } -> same_as<_Iter>;
       { std::as_const(__iter) - __n } -> same_as<_Iter>;
-      { __iter - __iter } -> same_as<__iter_diff_t<_Iter>>;
+      { __iter - __iter } -> same_as<__iterator_difference_type<_Iter>>;
-      { std::as_const(__iter) - __iter } -> same_as<__iter_diff_t<_Iter>>;
+      { std::as_const(__iter) - __iter } -> same_as<__iterator_difference_type<_Iter>>;
-      { __iter - std::as_const(__iter) } -> same_as<__iter_diff_t<_Iter>>;
+      { __iter - std::as_const(__iter) } -> same_as<__iterator_difference_type<_Iter>>;
-      { std::as_const(__iter) - std::as_const(__iter) } -> same_as<__iter_diff_t<_Iter>>;
+      { std::as_const(__iter) - std::as_const(__iter) } -> same_as<__iterator_difference_type<_Iter>>;
-      { __iter[__n] } -> convertible_to<__iter_reference<_Iter>>;
+      { __iter[__n] } -> convertible_to<__iterator_reference<_Iter>>;
-      { std::as_const(__iter)[__n] } -> convertible_to<__iter_reference<_Iter>>;
+      { std::as_const(__iter)[__n] } -> convertible_to<__iterator_reference<_Iter>>;
       { __iter < __iter } -> __boolean_testable;
       { std::as_const(__iter) < __iter } -> __boolean_testable;

lib/libcxx/include/__iterator/distance.h+40-18

 @@ -10,41 +10,66 @@
 #ifndef _LIBCPP___ITERATOR_DISTANCE_H
 #define _LIBCPP___ITERATOR_DISTANCE_H
+#include <__algorithm/for_each_segment.h>
+#include <__concepts/same_as.h>
 #include <__config>
 #include <__iterator/concepts.h>
 #include <__iterator/incrementable_traits.h>
 #include <__iterator/iterator_traits.h>
+#include <__iterator/segmented_iterator.h>
 #include <__ranges/access.h>
 #include <__ranges/concepts.h>
 #include <__ranges/size.h>
 #include <__type_traits/decay.h>
+#include <__type_traits/enable_if.h>
 #include <__type_traits/remove_cvref.h>
+#include <__utility/move.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 #endif
+_LIBCPP_PUSH_MACROS
+#include <__undef_macros>
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <class _InputIter>
+#if _LIBCPP_STD_VER >= 20
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 typename iterator_traits<_InputIter>::difference_type
+template <class _Iter>
-__distance(_InputIter __first, _InputIter __last, input_iterator_tag) {
+using __iter_distance_t _LIBCPP_NODEBUG = std::iter_difference_t<_Iter>;
-  typename iterator_traits<_InputIter>::difference_type __r(0);
+#else
-  for (; __first != __last; ++__first)
+template <class _Iter>
-    ++__r;
+using __iter_distance_t _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::difference_type;
-  return __r;
+#endif
-}
-template <class _RandIter>
+template <class _RandIter, __enable_if_t<__has_random_access_iterator_category<_RandIter>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 typename iterator_traits<_RandIter>::difference_type
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 __iter_distance_t<_RandIter>
-__distance(_RandIter __first, _RandIter __last, random_access_iterator_tag) {
+__distance(_RandIter __first, _RandIter __last) {
   return __last - __first;
 }
+template <class _InputIter, class _Sent>
+inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 __iter_distance_t<_InputIter>
+__distance(_InputIter __first, _Sent __last) {
+  __iter_distance_t<_InputIter> __r(0);
+#if _LIBCPP_STD_VER >= 20
+  if constexpr (same_as<_InputIter, _Sent> && __is_segmented_iterator_v<_InputIter>) {
+    std::__for_each_segment(__first, __last, [&__r](auto __lfirst, auto __llast) {
+      __r += std::__distance(__lfirst, __llast);
+    });
+  } else
+#endif
+  {
+    for (; __first != __last; ++__first)
+      ++__r;
+  }
+  return __r;
+}
 template <class _InputIter>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 typename iterator_traits<_InputIter>::difference_type
 distance(_InputIter __first, _InputIter __last) {
-  return std::__distance(__first, __last, typename iterator_traits<_InputIter>::iterator_category());
+  return std::__distance(__first, __last);
 }
 #if _LIBCPP_STD_VER >= 20
 @@ -56,12 +81,7 @@ struct __distance {
   template <class _Ip, sentinel_for<_Ip> _Sp>
     requires(!sized_sentinel_for<_Sp, _Ip>)
   _LIBCPP_HIDE_FROM_ABI constexpr iter_difference_t<_Ip> operator()(_Ip __first, _Sp __last) const {
-    iter_difference_t<_Ip> __n = 0;
+    return std::__distance(std::move(__first), std::move(__last));
-    while (__first != __last) {
-      ++__first;
-      ++__n;
-    }
-    return __n;
   }
   template <class _Ip, sized_sentinel_for<decay_t<_Ip>> _Sp>
 @@ -92,4 +112,6 @@ inline constexpr auto distance = __distance{};
 _LIBCPP_END_NAMESPACE_STD
+_LIBCPP_POP_MACROS
 #endif // _LIBCPP___ITERATOR_DISTANCE_H

lib/libcxx/include/__iterator/front_insert_iterator.h+1-7

 @@ -26,15 +26,9 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Container>
 class front_insert_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<front_insert_iterator<_Container>, output_iterator_tag, void, void, void, void> {
-    : public iterator<output_iterator_tag, void, void, void, void>
-#endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
   _Container* container;

lib/libcxx/include/__iterator/insert_iterator.h+1-7

 @@ -35,15 +35,9 @@ template <class _Container>
 using __insert_iterator_iter_t _LIBCPP_NODEBUG = typename _Container::iterator;
 #endif
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Container>
 class insert_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<insert_iterator<_Container>, output_iterator_tag, void, void, void, void> {
-    : public iterator<output_iterator_tag, void, void, void, void>
-#endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
   _Container* container;
   __insert_iterator_iter_t<_Container> iter;

lib/libcxx/include/__iterator/istream_iterator.h+6-7

...	@@ -25,15 +25,14 @@	...	@@ -25,15 +25,14 @@
25		25
26	_LIBCPP_BEGIN_NAMESPACE_STD	26	_LIBCPP_BEGIN_NAMESPACE_STD
27		27
28	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
29	template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>	28	template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT>, class _Distance = ptrdiff_t>
30	class istream_iterator	29	class istream_iterator
31	#if _LIBCPP_STD_VER <= 14 \|\| !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)	30	: public __iterator_base<istream_iterator<_Tp, _CharT, _Traits, _Distance>,
32	: public iterator<input_iterator_tag, _Tp, _Distance, const _Tp*, const _Tp&>	31	input_iterator_tag,
33	#endif	32	_Tp,
34	{	33	_Distance,
35	_LIBCPP_SUPPRESS_DEPRECATED_POP	34	const _Tp*,
36		35	const _Tp&> {
37	public:	36	public:
38	typedef input_iterator_tag iterator_category;	37	typedef input_iterator_tag iterator_category;
39	typedef _Tp value_type;	38	typedef _Tp value_type;

lib/libcxx/include/__iterator/istreambuf_iterator.h+6-7

...	@@ -25,15 +25,14 @@	...	@@ -25,15 +25,14 @@
25		25
26	_LIBCPP_BEGIN_NAMESPACE_STD	26	_LIBCPP_BEGIN_NAMESPACE_STD
27		27
28	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
29	template <class _CharT, class _Traits>	28	template <class _CharT, class _Traits>
30	class istreambuf_iterator	29	class istreambuf_iterator
31	#if _LIBCPP_STD_VER <= 14 \|\| !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)	30	: public __iterator_base<istreambuf_iterator<_CharT, _Traits>,
32	: public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, _CharT*, _CharT>	31	input_iterator_tag,
33	#endif	32	_CharT,
34	{	33	typename _Traits::off_type,
35	_LIBCPP_SUPPRESS_DEPRECATED_POP	34	_CharT*,
36		35	_CharT> {
37	public:	36	public:
38	typedef input_iterator_tag iterator_category;	37	typedef input_iterator_tag iterator_category;
39	typedef _CharT value_type;	38	typedef _CharT value_type;

lib/libcxx/include/__iterator/iter_move.h+1-1

...	@@ -40,7 +40,7 @@ void iter_move() = delete;	...	@@ -40,7 +40,7 @@ void iter_move() = delete;
40		40
41	template <class _Tp>	41	template <class _Tp>
42	concept __unqualified_iter_move = __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {	42	concept __unqualified_iter_move = __class_or_enum<remove_cvref_t<_Tp>> && requires(_Tp&& __t) {
43	// NOLINTNEXTLINE(libcpp-robust-against-adl) iter_swap ADL calls should only be made through ranges::iter_swap	43	// NOLINTNEXTLINE(libcpp-robust-against-adl) iter_move ADL calls should only be made through ranges::iter_move
44	iter_move(std::forward<_Tp>(__t));	44	iter_move(std::forward<_Tp>(__t));
45	};	45	};
46		46

lib/libcxx/include/__iterator/iterator.h+13

...	@@ -28,6 +28,19 @@ struct _LIBCPP_DEPRECATED_IN_CXX17 iterator {	...	@@ -28,6 +28,19 @@ struct _LIBCPP_DEPRECATED_IN_CXX17 iterator {
28	typedef _Category iterator_category;	28	typedef _Category iterator_category;
29	};	29	};
30		30
		31	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
		32	#ifdef _LIBCPP_ABI_NO_ITERATOR_BASES
		33	template <class _Derived>
		34	struct __no_iterator_base {};
		35
		36	template <class _Derived, class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
		37	using __iterator_base _LIBCPP_NODEBUG = __no_iterator_base<_Derived>;
		38	#else
		39	template <class _Derived, class _Category, class _Tp, class _Distance, class _Pointer, class _Reference>
		40	using __iterator_base _LIBCPP_NODEBUG = iterator<_Category, _Tp, _Distance, _Pointer, _Reference>;
		41	#endif
		42	_LIBCPP_SUPPRESS_DEPRECATED_POP
		43
31	_LIBCPP_END_NAMESPACE_STD	44	_LIBCPP_END_NAMESPACE_STD
32		45
33	#endif // _LIBCPP___ITERATOR_ITERATOR_H	46	#endif // _LIBCPP___ITERATOR_ITERATOR_H

lib/libcxx/include/__iterator/iterator_traits.h+13-14

 @@ -420,44 +420,43 @@ using __has_exactly_bidirectional_iterator_category _LIBCPP_NODEBUG =
                           !__has_iterator_category_convertible_to<_Tp, random_access_iterator_tag>::value>;
 template <class _InputIterator>
-using __iter_value_type _LIBCPP_NODEBUG = typename iterator_traits<_InputIterator>::value_type;
+using __iterator_value_type _LIBCPP_NODEBUG = typename iterator_traits<_InputIterator>::value_type;
 #if _LIBCPP_STD_VER >= 23
 template <class _InputIterator>
-using __iter_key_type _LIBCPP_NODEBUG = remove_const_t<tuple_element_t<0, __iter_value_type<_InputIterator>>>;
+using __iter_key_type _LIBCPP_NODEBUG = remove_const_t<tuple_element_t<0, __iterator_value_type<_InputIterator>>>;
 template <class _InputIterator>
-using __iter_mapped_type _LIBCPP_NODEBUG = tuple_element_t<1, __iter_value_type<_InputIterator>>;
+using __iter_mapped_type _LIBCPP_NODEBUG = tuple_element_t<1, __iterator_value_type<_InputIterator>>;
 template <class _InputIterator>
 using __iter_to_alloc_type _LIBCPP_NODEBUG =
-    pair<const tuple_element_t<0, __iter_value_type<_InputIterator>>,
+    pair<const tuple_element_t<0, __iterator_value_type<_InputIterator>>,
-         tuple_element_t<1, __iter_value_type<_InputIterator>>>;
+         tuple_element_t<1, __iterator_value_type<_InputIterator>>>;
 #else
 template <class _InputIterator>
-using __iter_key_type _LIBCPP_NODEBUG =
+using __iter_key_type _LIBCPP_NODEBUG = __remove_const_t<typename __iterator_value_type<_InputIterator>::first_type>;
-    __remove_const_t<typename iterator_traits<_InputIterator>::value_type::first_type>;
 template <class _InputIterator>
-using __iter_mapped_type _LIBCPP_NODEBUG = typename iterator_traits<_InputIterator>::value_type::second_type;
+using __iter_mapped_type _LIBCPP_NODEBUG = typename __iterator_value_type<_InputIterator>::second_type;
 template <class _InputIterator>
 using __iter_to_alloc_type _LIBCPP_NODEBUG =
-    pair<const typename iterator_traits<_InputIterator>::value_type::first_type,
+    pair<const typename __iterator_value_type<_InputIterator>::first_type,
-         typename iterator_traits<_InputIterator>::value_type::second_type>;
+         typename __iterator_value_type<_InputIterator>::second_type>;
 #endif // _LIBCPP_STD_VER >= 23
 template <class _Iter>
-using __iterator_category_type _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::iterator_category;
+using __iterator_iterator_category _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::iterator_category;
 template <class _Iter>
-using __iterator_pointer_type _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::pointer;
+using __iterator_pointer _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::pointer;
 template <class _Iter>
-using __iter_diff_t _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::difference_type;
+using __iterator_difference_type _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::difference_type;
 template <class _Iter>
-using __iter_reference _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::reference;
+using __iterator_reference _LIBCPP_NODEBUG = typename iterator_traits<_Iter>::reference;
 #if _LIBCPP_STD_VER >= 20

lib/libcxx/include/__iterator/ostream_iterator.h+1-7

 @@ -24,15 +24,9 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Tp, class _CharT = char, class _Traits = char_traits<_CharT> >
 class ostream_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<ostream_iterator<_Tp, _CharT, _Traits>, output_iterator_tag, void, void, void, void> {
-    : public iterator<output_iterator_tag, void, void, void, void>
-#endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
   typedef output_iterator_tag iterator_category;
   typedef void value_type;

lib/libcxx/include/__iterator/ostreambuf_iterator.h+1-7

 @@ -25,15 +25,9 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _CharT, class _Traits>
 class ostreambuf_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<ostreambuf_iterator<_CharT, _Traits>, output_iterator_tag, void, void, void, void> {
-    : public iterator<output_iterator_tag, void, void, void, void>
-#endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 public:
   typedef output_iterator_tag iterator_category;
   typedef void value_type;

lib/libcxx/include/__iterator/reverse_iterator.h+8-13

 @@ -46,21 +46,16 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _Iter>
 class reverse_iterator
-#if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<reverse_iterator<_Iter>,
-    : public iterator<typename iterator_traits<_Iter>::iterator_category,
+                             typename iterator_traits<_Iter>::iterator_category,
-                      typename iterator_traits<_Iter>::value_type,
+                             typename iterator_traits<_Iter>::value_type,
-                      typename iterator_traits<_Iter>::difference_type,
+                             typename iterator_traits<_Iter>::difference_type,
-                      typename iterator_traits<_Iter>::pointer,
+                             typename iterator_traits<_Iter>::pointer,
-                      typename iterator_traits<_Iter>::reference>
+                             typename iterator_traits<_Iter>::reference> {
-#endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 private:
-#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
+#ifndef _LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER
   _Iter __t_; // no longer used as of LWG #2360, not removed due to ABI break
 #endif
 @@ -91,7 +86,7 @@ public:
   using reference       = typename iterator_traits<_Iter>::reference;
 #endif
-#ifndef _LIBCPP_ABI_NO_ITERATOR_BASES
+#ifndef _LIBCPP_ABI_NO_REVERSE_ITERATOR_SECOND_MEMBER
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator() : __t_(), current() {}
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 explicit reverse_iterator(_Iter __x) : __t_(__x), current(__x) {}

lib/libcxx/include/__iterator/segmented_iterator.h+3-8

 @@ -67,18 +67,13 @@ struct __segmented_iterator_traits;
 */
 template <class _Tp, size_t = 0>
-struct __has_specialization : false_type {};
+inline const bool __has_specialization_v = false;
 template <class _Tp>
-struct __has_specialization<_Tp, sizeof(_Tp) * 0> : true_type {};
+inline const bool __has_specialization_v<_Tp, sizeof(_Tp) * 0> = true;
 template <class _Iterator>
-using __is_segmented_iterator _LIBCPP_NODEBUG = __has_specialization<__segmented_iterator_traits<_Iterator> >;
+inline const bool __is_segmented_iterator_v = __has_specialization_v<__segmented_iterator_traits<_Iterator> >;
-template <class _SegmentedIterator>
-struct __has_random_access_local_iterator
-    : __has_random_access_iterator_category<
-          typename __segmented_iterator_traits< _SegmentedIterator >::__local_iterator > {};
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__iterator/static_bounded_iter.h+3-3

...	@@ -99,9 +99,9 @@ struct __static_bounded_iter {	...	@@ -99,9 +99,9 @@ struct __static_bounded_iter {
99		99
100	template <class _OtherIterator,	100	template <class _OtherIterator,
101	__enable_if_t<	101	__enable_if_t<
102	_And< is_convertible<const _OtherIterator&, _Iterator>,	102	_And<is_convertible<const _OtherIterator&, _Iterator>,
103	_Or<is_same<reference, __iter_reference<_OtherIterator> >,	103	_Or<is_same<reference, __iterator_reference<_OtherIterator> >,
104	is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIterator> > > > >::value,	104	is_same<reference, __make_const_lvalue_ref<__iterator_reference<_OtherIterator> > > > >::value,
105	int> = 0>	105	int> = 0>
106	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR	106	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR
107	__static_bounded_iter(__static_bounded_iter<_OtherIterator, _Size> const& __other) _NOEXCEPT	107	__static_bounded_iter(__static_bounded_iter<_OtherIterator, _Size> const& __other) _NOEXCEPT

lib/libcxx/include/__iterator/wrap_iter.h+8-6

 @@ -49,12 +49,12 @@ private:
 public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter() _NOEXCEPT : __i_() {}
-  template <
+  template <class _OtherIter,
-      class _OtherIter,
+            __enable_if_t<
-      __enable_if_t< _And< is_convertible<const _OtherIter&, _Iter>,
+                _And<is_convertible<const _OtherIter&, _Iter>,
-                           _Or<is_same<reference, __iter_reference<_OtherIter> >,
+                     _Or<is_same<reference, __iterator_reference<_OtherIter> >,
-                               is_same<reference, __make_const_lvalue_ref<__iter_reference<_OtherIter> > > > >::value,
+                         is_same<reference, __make_const_lvalue_ref<__iterator_reference<_OtherIter> > > > >::value,
-                     int> = 0>
+                int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __wrap_iter(const __wrap_iter<_OtherIter>& __u) _NOEXCEPT
       : __i_(__u.__i_) {}
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 reference operator*() const _NOEXCEPT { return *__i_; }
 @@ -117,6 +117,8 @@ private:
   friend class span;
   template <class _Tp, size_t _Size>
   friend struct array;
+  template <class _Tp, class>
+  friend struct __optional_iterator;
 };
 template <class _Iter1>

lib/libcxx/include/__locale+3-10

...	@@ -57,9 +57,8 @@ _LIBCPP_HIDE_FROM_ABI const _Facet& use_facet(const locale&);	...	@@ -57,9 +57,8 @@ _LIBCPP_HIDE_FROM_ABI const _Facet& use_facet(const locale&);
57	class _LIBCPP_EXPORTED_FROM_ABI locale {	57	class _LIBCPP_EXPORTED_FROM_ABI locale {
58	public:	58	public:
59	// locale is essentially a shared_ptr that doesn't support weak_ptrs and never got a move constructor,	59	// locale is essentially a shared_ptr that doesn't support weak_ptrs and never got a move constructor,
60	// so it is trivially relocatable. Like shared_ptr, it is also replaceable.	60	// so it is trivially relocatable.
61	using __trivially_relocatable _LIBCPP_NODEBUG = locale;	61	using __trivially_relocatable _LIBCPP_NODEBUG = locale;
62	using __replaceable _LIBCPP_NODEBUG = locale;
63		62
64	// types:	63	// types:
65	class _LIBCPP_EXPORTED_FROM_ABI facet;	64	class _LIBCPP_EXPORTED_FROM_ABI facet;
...	@@ -389,7 +388,7 @@ public:	...	@@ -389,7 +388,7 @@ public:
389	static const mask xdigit = _ISXDIGIT;	388	static const mask xdigit = _ISXDIGIT;
390	static const mask blank = _ISBLANK;	389	static const mask blank = _ISBLANK;
391	static const mask __regex_word = 0x8000;	390	static const mask __regex_word = 0x8000;
392	# elif defined(_NEWLIB_VERSION)	391	# elif _LIBCPP_LIBC_NEWLIB
393	// Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.	392	// Same type as Newlib's _ctype_ array in newlib/libc/include/ctype.h.
394	typedef char mask;	393	typedef char mask;
395	// In case char is signed, static_cast is needed to avoid warning on	394	// In case char is signed, static_cast is needed to avoid warning on
...	@@ -585,7 +584,7 @@ public:	...	@@ -585,7 +584,7 @@ public:
585	# ifdef _CACHED_RUNES	584	# ifdef _CACHED_RUNES
586	static const size_t table_size = _CACHED_RUNES;	585	static const size_t table_size = _CACHED_RUNES;
587	# else	586	# else
588	static const size_t table_size = 256; // FIXME: Don't hardcode this.	587	static const size_t table_size = 256;
589	# endif	588	# endif
590	_LIBCPP_HIDE_FROM_ABI const mask* table() const _NOEXCEPT { return __tab_; }	589	_LIBCPP_HIDE_FROM_ABI const mask* table() const _NOEXCEPT { return __tab_; }
591	static const mask* classic_table() _NOEXCEPT;	590	static const mask* classic_table() _NOEXCEPT;
...	@@ -1478,9 +1477,6 @@ public:	...	@@ -1478,9 +1477,6 @@ public:
1478		1477
1479	protected:	1478	protected:
1480	~numpunct_byname() override;	1479	~numpunct_byname() override;
1481
1482	private:
1483	void __init(const char*);
1484	};	1480	};
1485		1481
1486	# if _LIBCPP_HAS_WIDE_CHARACTERS	1482	# if _LIBCPP_HAS_WIDE_CHARACTERS
...	@@ -1495,9 +1491,6 @@ public:	...	@@ -1495,9 +1491,6 @@ public:
1495		1491
1496	protected:	1492	protected:
1497	~numpunct_byname() override;	1493	~numpunct_byname() override;
1498
1499	private:
1500	void __init(const char*);
1501	};	1494	};
1502	# endif // _LIBCPP_HAS_WIDE_CHARACTERS	1495	# endif // _LIBCPP_HAS_WIDE_CHARACTERS
1503		1496

lib/libcxx/include/__locale_dir/locale_base_api.h+5-28

 @@ -57,15 +57,11 @@
 //  float               __strtof(const char*, char**, __locale_t);
 //  double              __strtod(const char*, char**, __locale_t);
 //  long double         __strtold(const char*, char**, __locale_t);
-//  long long           __strtoll(const char*, char**, __locale_t);
-//  unsigned long long  __strtoull(const char*, char**, __locale_t);
 // }
 //
 // Character manipulation functions
 // --------------------------------
 // namespace __locale {
-//  int     __isdigit(int, __locale_t);  // required by the headers
-//  int     __isxdigit(int, __locale_t); // required by the headers
 //  int     __toupper(int, __locale_t);
 //  int     __tolower(int, __locale_t);
 //  int     __strcoll(const char*, const char*, __locale_t);
 @@ -106,7 +102,6 @@
 //
 //  int     __snprintf(char*, size_t, __locale_t, const char*, ...); // required by the headers
 //  int     __asprintf(char**, __locale_t, const char*, ...);        // required by the headers
-//  int     __sscanf(const char*, __locale_t, const char*, ...);     // required by the headers
 // }
 #if _LIBCPP_HAS_LOCALIZATION
 @@ -115,7 +110,6 @@
 #    include <__locale_dir/support/apple.h>
 #  elif defined(__FreeBSD__)
 #    include <__locale_dir/support/freebsd.h>
-/* zig patch: https://github.com/llvm/llvm-project/pull/143055 */
 #  elif defined(__NetBSD__)
 #    include <__locale_dir/support/netbsd.h>
 #  elif defined(_LIBCPP_MSVCRT_LIKE)
 @@ -124,20 +118,20 @@
 #    include <__locale_dir/support/fuchsia.h>
 #  elif defined(__linux__)
 #    include <__locale_dir/support/linux.h>
+#  elif _LIBCPP_LIBC_NEWLIB
+#    include <__locale_dir/support/newlib.h>
+#  elif defined(_AIX)
+#    include <__locale_dir/support/aix.h>
 #  else
 // TODO: This is a temporary definition to bridge between the old way we defined the locale base API
 //       (by providing global non-reserved names) and the new API. As we move individual platforms
 //       towards the new way of defining the locale base API, this should disappear since each platform
 //       will define those directly.
-#    if defined(_AIX) || defined(__MVS__)
+#    if defined(__MVS__)
 #      include <__locale_dir/locale_base_api/ibm.h>
-#    elif defined(__ANDROID__)
-#      include <__locale_dir/locale_base_api/android.h>
 #    elif defined(__OpenBSD__)
 #      include <__locale_dir/locale_base_api/openbsd.h>
-#    elif defined(__wasi__) || _LIBCPP_HAS_MUSL_LIBC
-#      include <__locale_dir/locale_base_api/musl.h>
 #    endif
 #    include <__locale_dir/locale_base_api/bsd_locale_fallbacks.h>
 @@ -197,21 +191,9 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __
   return strtold_l(__nptr, __endptr, __loc);
 }
-inline _LIBCPP_HIDE_FROM_ABI long long __strtoll(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
-  return strtoll_l(__nptr, __endptr, __base, __loc);
-}
-inline _LIBCPP_HIDE_FROM_ABI unsigned long long
-__strtoull(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
-  return strtoull_l(__nptr, __endptr, __base, __loc);
-}
 //
 // Character manipulation functions
 //
-inline _LIBCPP_HIDE_FROM_ABI int __isdigit(int __ch, __locale_t __loc) { return isdigit_l(__ch, __loc); }
-inline _LIBCPP_HIDE_FROM_ABI int __isxdigit(int __ch, __locale_t __loc) { return isxdigit_l(__ch, __loc); }
 #    if defined(_LIBCPP_BUILDING_LIBRARY)
 inline _LIBCPP_HIDE_FROM_ABI int __strcoll(const char* __s1, const char* __s2, __locale_t __loc) {
   return strcoll_l(__s1, __s2, __loc);
 @@ -307,11 +289,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __
     char** __s, __locale_t __loc, const char* __format, _Args&&... __args) {
   return std::__libcpp_asprintf_l(__s, __loc, __format, std::forward<_Args>(__args)...);
 }
-template <class... _Args>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __sscanf(
-    const char* __s, __locale_t __loc, const char* __format, _Args&&... __args) {
-  return std::__libcpp_sscanf_l(__s, __loc, __format, std::forward<_Args>(__args)...);
-}
 _LIBCPP_DIAGNOSTIC_POP
 #    undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT

lib/libcxx/include/__locale_dir/locale_base_api/bsd_locale_fallbacks.h-10

...	@@ -125,16 +125,6 @@ inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __libcpp_asprintf_l(	...	@@ -125,16 +125,6 @@ inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __libcpp_asprintf_l(
125	return __res;	125	return __res;
126	}	126	}
127		127
128	inline _LIBCPP_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __libcpp_sscanf_l(
129	const char* __s, locale_t __l, const char* __format, ...) {
130	va_list __va;
131	va_start(__va, __format);
132	__locale_guard __current(__l);
133	int __res = vsscanf(__s, __format, __va);
134	va_end(__va);
135	return __res;
136	}
137
138	_LIBCPP_END_NAMESPACE_STD	128	_LIBCPP_END_NAMESPACE_STD
139		129
140	#endif // _LIBCPP___LOCALE_DIR_LOCALE_BASE_API_BSD_LOCALE_FALLBACKS_H	130	#endif // _LIBCPP___LOCALE_DIR_LOCALE_BASE_API_BSD_LOCALE_FALLBACKS_H

lib/libcxx/include/__locale_dir/messages.h+1-1

...	@@ -22,7 +22,7 @@	...	@@ -22,7 +22,7 @@
22		22
23	# if defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__))	23	# if defined(__unix__) \|\| (defined(__APPLE__) && defined(__MACH__))
24	// Most unix variants have catopen. These are the specific ones that don't.	24	// Most unix variants have catopen. These are the specific ones that don't.
25	# if !defined(__BIONIC__) && !defined(_NEWLIB_VERSION) && !defined(__EMSCRIPTEN__)	25	# if !defined(__BIONIC__) && !_LIBCPP_LIBC_NEWLIB && !defined(__EMSCRIPTEN__)
26	# define _LIBCPP_HAS_CATOPEN 1	26	# define _LIBCPP_HAS_CATOPEN 1
27	# include <nl_types.h>	27	# include <nl_types.h>
28	# else	28	# else

lib/libcxx/include/__locale_dir/money.h+2-2

...	@@ -433,7 +433,7 @@ bool money_get<_CharT, _InputIterator>::__do_get(	...	@@ -433,7 +433,7 @@ bool money_get<_CharT, _InputIterator>::__do_get(
433	__err \|= ios_base::failbit;	433	__err \|= ios_base::failbit;
434	return false;	434	return false;
435	}	435	}
436	for (++__b; __fd > 0; --__fd, ++__b) {	436	for (++__b; __fd > 0; --__fd, (void)++__b) {
437	if (__b == __e \|\| !__ct.is(ctype_base::digit, *__b)) {	437	if (__b == __e \|\| !__ct.is(ctype_base::digit, *__b)) {
438	__err \|= ios_base::failbit;	438	__err \|= ios_base::failbit;
439	return false;	439	return false;
...	@@ -451,7 +451,7 @@ bool money_get<_CharT, _InputIterator>::__do_get(	...	@@ -451,7 +451,7 @@ bool money_get<_CharT, _InputIterator>::__do_get(
451	}	451	}
452	}	452	}
453	if (__trailing_sign) {	453	if (__trailing_sign) {
454	for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, ++__b) {	454	for (unsigned __i = 1; __i < __trailing_sign->size(); ++__i, (void)++__b) {
455	if (__b == __e \|\| __b != (__trailing_sign)[__i]) {	455	if (__b == __e \|\| __b != (__trailing_sign)[__i]) {
456	__err \|= ios_base::failbit;	456	__err \|= ios_base::failbit;
457	return false;	457	return false;

lib/libcxx/include/__locale_dir/num.h+190-243

...	@@ -9,8 +9,10 @@	...	@@ -9,8 +9,10 @@
9	#ifndef _LIBCPP___LOCALE_DIR_NUM_H	9	#ifndef _LIBCPP___LOCALE_DIR_NUM_H
10	#define _LIBCPP___LOCALE_DIR_NUM_H	10	#define _LIBCPP___LOCALE_DIR_NUM_H
11		11
		12	#include <__algorithm/copy.h>
12	#include <__algorithm/find.h>	13	#include <__algorithm/find.h>
13	#include <__algorithm/reverse.h>	14	#include <__algorithm/reverse.h>
		15	#include <__algorithm/simd_utils.h>
14	#include <__charconv/to_chars_integral.h>	16	#include <__charconv/to_chars_integral.h>
15	#include <__charconv/traits.h>	17	#include <__charconv/traits.h>
16	#include <__config>	18	#include <__config>
...	@@ -22,6 +24,7 @@	...	@@ -22,6 +24,7 @@
22	#include <__locale_dir/scan_keyword.h>	24	#include <__locale_dir/scan_keyword.h>
23	#include <__memory/unique_ptr.h>	25	#include <__memory/unique_ptr.h>
24	#include <__system_error/errc.h>	26	#include <__system_error/errc.h>
		27	#include <__type_traits/is_signed.h>
25	#include <cerrno>	28	#include <cerrno>
26	#include <ios>	29	#include <ios>
27	#include <streambuf>	30	#include <streambuf>
...	@@ -46,9 +49,9 @@ struct _LIBCPP_EXPORTED_FROM_ABI __num_get_base {	...	@@ -46,9 +49,9 @@ struct _LIBCPP_EXPORTED_FROM_ABI __num_get_base {
46	static int __get_base(ios_base&);	49	static int __get_base(ios_base&);
47	static const char __src[33]; // "0123456789abcdefABCDEFxX+-pPiInN"	50	static const char __src[33]; // "0123456789abcdefABCDEFxX+-pPiInN"
48	// count of leading characters in __src used for parsing integers ("012..X+-")	51	// count of leading characters in __src used for parsing integers ("012..X+-")
49	static const size_t __int_chr_cnt = 26;	52	static inline const size_t __int_chr_cnt = 26;
50	// count of leading characters in __src used for parsing floating-point values ("012..-pP")	53	// count of leading characters in __src used for parsing floating-point values ("012..-pP")
51	static const size_t __fp_chr_cnt = 28;	54	static inline const size_t __fp_chr_cnt = 28;
52	};	55	};
53		56
54	template <class _CharT>	57	template <class _CharT>
...	@@ -71,7 +74,8 @@ struct __num_get : protected __num_get_base {	...	@@ -71,7 +74,8 @@ struct __num_get : protected __num_get_base {
71		74
72	[[__deprecated__("This exists only for ABI compatibility")]] static string	75	[[__deprecated__("This exists only for ABI compatibility")]] static string
73	__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);	76	__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _CharT& __thousands_sep);
74	static int __stage2_int_loop(	77
		78	[[__deprecated__("This exists only for ABI compatibility")]] static int __stage2_int_loop(
75	_CharT __ct,	79	_CharT __ct,
76	int __base,	80	int __base,
77	char* __a,	81	char* __a,
...	@@ -83,11 +87,24 @@ struct __num_get : protected __num_get_base {	...	@@ -83,11 +87,24 @@ struct __num_get : protected __num_get_base {
83	unsigned*& __g_end,	87	unsigned*& __g_end,
84	_CharT* __atoms);	88	_CharT* __atoms);
85		89
86	_LIBCPP_HIDE_FROM_ABI static string __stage2_int_prep(ios_base& __iob, _CharT& __thousands_sep) {	90	_LIBCPP_HIDE_FROM_ABI static ptrdiff_t __atoms_offset(const _CharT* __atoms, _CharT __val) {
87	locale __loc = __iob.getloc();	91	// TODO: Remove the manual vectorization once https://llvm.org/PR168551 is resolved
88	const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc);	92	# if _LIBCPP_HAS_ALGORITHM_VECTOR_UTILS
89	__thousands_sep = __np.thousands_sep();	93	if constexpr (is_same<_CharT, char>::value) {
90	return __np.grouping();	94	// TODO(LLVM 24): This can be removed, since -Wpsabi doesn't warn on [[gnu::always_inline]] functions anymore.
		95	_LIBCPP_DIAGNOSTIC_PUSH
		96	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wpsabi")
		97	using __vec = __simd_vector<char, 32>;
		98	__vec __chars = std::__broadcast<__vec>(__val);
		99	__vec __cmp = std::__partial_load<__vec, __int_chr_cnt>(__atoms);
		100	auto __res = __chars == __cmp;
		101	if (std::__none_of(__res))
		102	return __int_chr_cnt;
		103	return std::min(__int_chr_cnt, std::__find_first_set(__res));
		104	_LIBCPP_DIAGNOSTIC_POP
		105	}
		106	# endif
		107	return std::find(__atoms, __atoms + __int_chr_cnt, __val) - __atoms;
91	}	108	}
92		109
93	_LIBCPP_HIDE_FROM_ABI const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const {	110	_LIBCPP_HIDE_FROM_ABI const _CharT* __do_widen(ios_base& __iob, _CharT* __atoms) const {
...	@@ -120,54 +137,6 @@ string __num_get<_CharT>::__stage2_float_prep(	...	@@ -120,54 +137,6 @@ string __num_get<_CharT>::__stage2_float_prep(
120	return __np.grouping();	137	return __np.grouping();
121	}	138	}
122		139
123	template <class _CharT>
124	int __num_get<_CharT>::__stage2_int_loop(
125	_CharT __ct,
126	int __base,
127	char* __a,
128	char*& __a_end,
129	unsigned& __dc,
130	_CharT __thousands_sep,
131	const string& __grouping,
132	unsigned* __g,
133	unsigned*& __g_end,
134	_CharT* __atoms) {
135	if (__a_end == __a && (__ct == __atoms[24] \|\| __ct == __atoms[25])) {
136	*__a_end++ = __ct == __atoms[24] ? '+' : '-';
137	__dc = 0;
138	return 0;
139	}
140	if (__grouping.size() != 0 && __ct == __thousands_sep) {
141	if (__g_end - __g < __num_get_buf_sz) {
142	*__g_end++ = __dc;
143	__dc = 0;
144	}
145	return 0;
146	}
147	ptrdiff_t __f = std::find(__atoms, __atoms + __int_chr_cnt, __ct) - __atoms;
148	if (__f >= 24)
149	return -1;
150	switch (__base) {
151	case 8:
152	case 10:
153	if (__f >= __base)
154	return -1;
155	break;
156	case 16:
157	if (__f < 22)
158	break;
159	if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0') {
160	__dc = 0;
161	*__a_end++ = __src[__f];
162	return 0;
163	}
164	return -1;
165	}
166	*__a_end++ = __src[__f];
167	++__dc;
168	return 0;
169	}
170
171	template <class _CharT>	140	template <class _CharT>
172	int __num_get<_CharT>::__stage2_float_loop(	141	int __num_get<_CharT>::__stage2_float_loop(
173	_CharT __ct,	142	_CharT __ct,
...	@@ -272,65 +241,6 @@ _LIBCPP_HIDE_FROM_ABI _Tp __num_get_float(const char* __a, const char* __a_end,	...	@@ -272,65 +241,6 @@ _LIBCPP_HIDE_FROM_ABI _Tp __num_get_float(const char* __a, const char* __a_end,
272	return 0;	241	return 0;
273	}	242	}
274		243
275	template <class _Tp>
276	_LIBCPP_HIDE_FROM_ABI _Tp
277	__num_get_signed_integral(const char* __a, const char* __a_end, ios_base::iostate& __err, int __base) {
278	if (__a != __a_end) {
279	__libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
280	errno = 0;
281	char* __p2;
282	long long __ll = __locale::__strtoll(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
283	__libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
284	if (__current_errno == 0)
285	errno = __save_errno;
286	if (__p2 != __a_end) {
287	__err = ios_base::failbit;
288	return 0;
289	} else if (__current_errno == ERANGE \|\| __ll < numeric_limits<_Tp>::min() \|\| numeric_limits<_Tp>::max() < __ll) {
290	__err = ios_base::failbit;
291	if (__ll > 0)
292	return numeric_limits<_Tp>::max();
293	else
294	return numeric_limits<_Tp>::min();
295	}
296	return static_cast<_Tp>(__ll);
297	}
298	__err = ios_base::failbit;
299	return 0;
300	}
301
302	template <class _Tp>
303	_LIBCPP_HIDE_FROM_ABI _Tp
304	__num_get_unsigned_integral(const char* __a, const char* __a_end, ios_base::iostate& __err, int __base) {
305	if (__a != __a_end) {
306	const bool __negate = *__a == '-';
307	if (__negate && ++__a == __a_end) {
308	__err = ios_base::failbit;
309	return 0;
310	}
311	__libcpp_remove_reference_t<decltype(errno)> __save_errno = errno;
312	errno = 0;
313	char* __p2;
314	unsigned long long __ll = __locale::__strtoull(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
315	__libcpp_remove_reference_t<decltype(errno)> __current_errno = errno;
316	if (__current_errno == 0)
317	errno = __save_errno;
318	if (__p2 != __a_end) {
319	__err = ios_base::failbit;
320	return 0;
321	} else if (__current_errno == ERANGE \|\| numeric_limits<_Tp>::max() < __ll) {
322	__err = ios_base::failbit;
323	return numeric_limits<_Tp>::max();
324	}
325	_Tp __res = static_cast<_Tp>(__ll);
326	if (__negate)
327	__res = -__res;
328	return __res;
329	}
330	__err = ios_base::failbit;
331	return 0;
332	}
333
334	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >	244	template <class _CharT, class _InputIterator = istreambuf_iterator<_CharT> >
335	class num_get : public locale::facet, private __num_get<_CharT> {	245	class num_get : public locale::facet, private __num_get<_CharT> {
336	public:	246	public:
...	@@ -468,137 +378,196 @@ protected:	...	@@ -468,137 +378,196 @@ protected:
468	return __b;	378	return __b;
469	}	379	}
470		380
471	template <class _Signed>	381	template <class _MaybeSigned>
472	_LIBCPP_HIDE_FROM_ABI iter_type	382	iter_type __do_get_integral(
473	__do_get_signed(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Signed& __v) const {	383	iter_type __first, iter_type __last, ios_base& __iob, ios_base::iostate& __err, _MaybeSigned& __v) const {
		384	using _Unsigned = __make_unsigned_t<_MaybeSigned>;
		385
474	// Stage 1	386	// Stage 1
475	int __base = this->__get_base(__iob);	387	int __base = this->__get_base(__iob);
476	// Stage 2	388
477	char_type __thousands_sep;	389	// Stages 2 & 3
478	const int __atoms_size = __num_get_base::__int_chr_cnt;	390	// These are combined into a single step where we parse the characters and calculate the value in one go instead of
479	char_type __atoms1[__atoms_size];	391	// storing the relevant characters first (in an allocated buffer) and parse the characters after we extracted them.
480	const char_type* __atoms = this->__do_widen(__iob, __atoms1);	392	// This makes the whole process significantly faster, since we avoid potential allocations and copies.
481	string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);	393
482	string __buf;	394	const auto& __numpunct = use_facet<numpunct<_CharT> >(__iob.getloc());
483	__buf.resize(__buf.capacity());	395	char_type __thousands_sep = __numpunct.thousands_sep();
484	char* __a = &__buf[0];	396	string __grouping = __numpunct.grouping();
485	char* __a_end = __a;	397
		398	char_type __atoms_buffer[__num_get_base::__int_chr_cnt];
		399	const char_type* __atoms = this->__do_widen(__iob, __atoms_buffer);
486	unsigned __g[__num_get_base::__num_get_buf_sz];	400	unsigned __g[__num_get_base::__num_get_buf_sz];
487	unsigned* __g_end = __g;	401	unsigned* __g_end = __g;
488	unsigned __dc = 0;	402	unsigned __dc = 0;
489	for (; __b != __e; ++__b) {	403
490	if (__a_end == __a + __buf.size()) {	404	if (__first == __last) {
491	size_t __tmp = __buf.size();	405	__err \|= ios_base::eofbit \| ios_base::failbit;
492	__buf.resize(2 * __buf.size());	406	__v = 0;
493	__buf.resize(__buf.capacity());	407	return __first;
494	__a = &__buf[0];	408	}
495	__a_end = __a + __tmp;	409
		410	while (!__grouping.empty() && *__first == __thousands_sep) {
		411	++__first;
		412	if (__g_end - __g < this->__num_get_buf_sz)
		413	*__g_end++ = 0;
		414	}
		415
		416	bool __negate = false;
		417	// __c == '+' \|\| __c == '-'
		418	if (auto __c = *__first; __c == __atoms[24] \|\| __c == __atoms[25]) {
		419	__negate = __c == __atoms[25];
		420	++__first;
		421	}
		422
		423	if (__first == __last) {
		424	__err \|= ios_base::eofbit \| ios_base::failbit;
		425	__v = 0;
		426	return __first;
		427	}
		428
		429	bool __parsed_num = false;
		430
		431	// If we don't have a pre-set base, figure it out and swallow any prefix
		432	if (__base == 0) {
		433	auto __c = *__first;
		434	// __c == '0'
		435	if (__c == __atoms[0]) {
		436	++__first;
		437	if (__first == __last) {
		438	__err \|= ios_base::eofbit;
		439	__v = 0;
		440	return __first;
		441	}
		442	// __c2 == 'x' \|\| __c2 == 'X'
		443	if (auto __c2 = *__first; __c2 == __atoms[22] \|\| __c2 == __atoms[23]) {
		444	__base = 16;
		445	++__first;
		446	} else {
		447	__base = 8;
		448	__parsed_num = true; // We only swallowed '0', so we've started to parse a number
		449	}
		450	} else {
		451	__base = 10;
		452	}
		453
		454	// If the base has been specified explicitly, try to swallow the appropriate prefix. We only need to do something
		455	// special for hex, since decimal has no prefix and octal's prefix is '0', which doesn't change the value that
		456	// we'll parse if we don't swallow it.
		457	} else if (__base == 16) {
		458	// Try to swallow '0x'
		459
		460	// *__first == '0'
		461	if (*__first == __atoms[0]) {
		462	++__first;
		463	if (__first == __last) {
		464	__err \|= ios_base::eofbit;
		465	__v = 0;
		466	return __first;
		467	}
		468	// __c == 'x' \|\| __c == 'X'
		469	if (auto __c = *__first; __c == __atoms[22] \|\| __c == __atoms[23])
		470	++__first;
		471	else
		472	__parsed_num = true; // We only swallowed '0', so we've started to parse a number
496	}	473	}
497	if (this->__stage2_int_loop(
498	*__b,
499	__base,
500	__a,
501	__a_end,
502	__dc,
503	__thousands_sep,
504	__grouping,
505	__g,
506	__g_end,
507	const_cast<char_type*>(__atoms)))
508	break;
509	}	474	}
510	if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)
511	*__g_end++ = __dc;
512	// Stage 3
513	__v = std::__num_get_signed_integral<_Signed>(__a, __a_end, __err, __base);
514	// Digit grouping checked
515	__check_grouping(__grouping, __g, __g_end, __err);
516	// EOF checked
517	if (__b == __e)
518	__err \|= ios_base::eofbit;
519	return __b;
520	}
521		475
522	template <class _Unsigned>	476	// Calculate the actual number
523	_LIBCPP_HIDE_FROM_ABI iter_type	477	_Unsigned __val = 0;
524	__do_get_unsigned(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, _Unsigned& __v) const {	478	bool __overflowed = false;
525	// Stage 1	479	for (; __first != __last; ++__first) {
526	int __base = this->__get_base(__iob);	480	auto __c = *__first;
527	// Stage 2	481	if (!__grouping.empty() && __c == __thousands_sep) {
528	char_type __thousands_sep;	482	if (__g_end - __g < this->__num_get_buf_sz) {
529	const int __atoms_size = __num_get_base::__int_chr_cnt;	483	*__g_end++ = __dc;
530	char_type __atoms1[__atoms_size];	484	__dc = 0;
531	const char_type* __atoms = this->__do_widen(__iob, __atoms1);	485	}
532	string __grouping = this->__stage2_int_prep(__iob, __thousands_sep);	486	continue;
533	string __buf;
534	__buf.resize(__buf.capacity());
535	char* __a = &__buf[0];
536	char* __a_end = __a;
537	unsigned __g[__num_get_base::__num_get_buf_sz];
538	unsigned* __g_end = __g;
539	unsigned __dc = 0;
540	for (; __b != __e; ++__b) {
541	if (__a_end == __a + __buf.size()) {
542	size_t __tmp = __buf.size();
543	__buf.resize(2 * __buf.size());
544	__buf.resize(__buf.capacity());
545	__a = &__buf[0];
546	__a_end = __a + __tmp;
547	}	487	}
548	if (this->__stage2_int_loop(	488	auto __offset = this->__atoms_offset(__atoms, __c);
549	*__b,	489	if (__offset >= 22) // Not a valid integer character
550	__base,	490	break;
551	__a,	491
552	__a_end,	492	if (__base == 16 && __offset >= 16)
553	__dc,	493	__offset -= 6;
554	__thousands_sep,	494	if (__offset >= __base)
555	__grouping,
556	__g,
557	__g_end,
558	const_cast<char_type*>(__atoms)))
559	break;	495	break;
		496	// __val = (__val * __base) + __offset
		497	__overflowed \|= __builtin_mul_overflow(__val, __base, std::addressof(__val)) \|\|
		498	__builtin_add_overflow(__val, __offset, std::addressof(__val));
		499	__parsed_num = true;
		500	++__dc;
		501	}
		502
		503	if (!__parsed_num) {
		504	__err \|= ios_base::failbit;
		505	__v = 0;
		506	} else if (__overflowed) {
		507	__err \|= ios_base::failbit;
		508	__v = is_signed<_MaybeSigned>::value && __negate
		509	? numeric_limits<_MaybeSigned>::min()
		510	: numeric_limits<_MaybeSigned>::max();
		511	} else if (!__negate) {
		512	if (__val > static_cast<_Unsigned>(numeric_limits<_MaybeSigned>::max())) {
		513	__err \|= ios_base::failbit;
		514	__v = numeric_limits<_MaybeSigned>::max();
		515	} else {
		516	__v = __val;
		517	}
		518	} else if (is_signed<_MaybeSigned>::value) {
		519	if (__val > static_cast<_Unsigned>(numeric_limits<_MaybeSigned>::max()) + 1) {
		520	__err \|= ios_base::failbit;
		521	__v = numeric_limits<_MaybeSigned>::min();
		522	} else if (__val == static_cast<_Unsigned>(numeric_limits<_MaybeSigned>::max()) + 1) {
		523	__v = numeric_limits<_MaybeSigned>::min();
		524	} else {
		525	__v = -__val;
		526	}
		527	} else {
		528	__v = -__val;
560	}	529	}
		530
561	if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)	531	if (__grouping.size() != 0 && __g_end - __g < __num_get_base::__num_get_buf_sz)
562	*__g_end++ = __dc;	532	*__g_end++ = __dc;
563	// Stage 3	533
564	__v = std::__num_get_unsigned_integral<_Unsigned>(__a, __a_end, __err, __base);
565	// Digit grouping checked	534	// Digit grouping checked
566	__check_grouping(__grouping, __g, __g_end, __err);	535	__check_grouping(__grouping, __g, __g_end, __err);
567	// EOF checked	536	// EOF checked
568	if (__b == __e)	537	if (__first == __last)
569	__err \|= ios_base::eofbit;	538	__err \|= ios_base::eofbit;
570	return __b;	539	return __first;
571	}	540	}
572		541
573	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const;	542	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, bool& __v) const;
574		543
575	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long& __v) const {	544	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long& __v) const {
576	return this->__do_get_signed(__b, __e, __iob, __err, __v);	545	return this->__do_get_integral(__b, __e, __iob, __err, __v);
577	}	546	}
578		547
579	virtual iter_type	548	virtual iter_type
580	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long long& __v) const {	549	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, long long& __v) const {
581	return this->__do_get_signed(__b, __e, __iob, __err, __v);	550	return this->__do_get_integral(__b, __e, __iob, __err, __v);
582	}	551	}
583		552
584	virtual iter_type	553	virtual iter_type
585	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned short& __v) const {	554	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned short& __v) const {
586	return this->__do_get_unsigned(__b, __e, __iob, __err, __v);	555	return this->__do_get_integral(__b, __e, __iob, __err, __v);
587	}	556	}
588		557
589	virtual iter_type	558	virtual iter_type
590	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned int& __v) const {	559	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned int& __v) const {
591	return this->__do_get_unsigned(__b, __e, __iob, __err, __v);	560	return this->__do_get_integral(__b, __e, __iob, __err, __v);
592	}	561	}
593		562
594	virtual iter_type	563	virtual iter_type
595	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long& __v) const {	564	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long& __v) const {
596	return this->__do_get_unsigned(__b, __e, __iob, __err, __v);	565	return this->__do_get_integral(__b, __e, __iob, __err, __v);
597	}	566	}
598		567
599	virtual iter_type	568	virtual iter_type
600	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long long& __v) const {	569	do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, unsigned long long& __v) const {
601	return this->__do_get_unsigned(__b, __e, __iob, __err, __v);	570	return this->__do_get_integral(__b, __e, __iob, __err, __v);
602	}	571	}
603		572
604	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, float& __v) const {	573	virtual iter_type do_get(iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, float& __v) const {
...	@@ -652,40 +621,13 @@ _InputIterator num_get<_CharT, _InputIterator>::do_get(	...	@@ -652,40 +621,13 @@ _InputIterator num_get<_CharT, _InputIterator>::do_get(
652	template <class _CharT, class _InputIterator>	621	template <class _CharT, class _InputIterator>
653	_InputIterator num_get<_CharT, _InputIterator>::do_get(	622	_InputIterator num_get<_CharT, _InputIterator>::do_get(
654	iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const {	623	iter_type __b, iter_type __e, ios_base& __iob, ios_base::iostate& __err, void*& __v) const {
655	// Stage 1	624	auto __flags = __iob.flags();
656	int __base = 16;	625	__iob.flags((__flags & ~ios_base::basefield & ~ios_base::uppercase) \| ios_base::hex);
657	// Stage 2	626	uintptr_t __ptr;
658	char_type __atoms[__num_get_base::__int_chr_cnt];	627	auto __res = __do_get_integral(__b, __e, __iob, __err, __ptr);
659	char_type __thousands_sep = char_type();	628	__iob.flags(__flags);
660	string __grouping;	629	__v = reinterpret_cast<void*>(__ptr);
661	std::use_facet<ctype<_CharT> >(__iob.getloc())	630	return __res;
662	.widen(__num_get_base::__src, __num_get_base::__src + __num_get_base::__int_chr_cnt, __atoms);
663	string __buf;
664	__buf.resize(__buf.capacity());
665	char* __a = &__buf[0];
666	char* __a_end = __a;
667	unsigned __g[__num_get_base::__num_get_buf_sz];
668	unsigned* __g_end = __g;
669	unsigned __dc = 0;
670	for (; __b != __e; ++__b) {
671	if (__a_end == __a + __buf.size()) {
672	size_t __tmp = __buf.size();
673	__buf.resize(2 * __buf.size());
674	__buf.resize(__buf.capacity());
675	__a = &__buf[0];
676	__a_end = __a + __tmp;
677	}
678	if (this->__stage2_int_loop(*__b, __base, __a, __a_end, __dc, __thousands_sep, __grouping, __g, __g_end, __atoms))
679	break;
680	}
681	// Stage 3
682	__buf.resize(__a_end - __a);
683	if (__locale::__sscanf(__buf.c_str(), _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
684	__err = ios_base::failbit;
685	// EOF checked
686	if (__b == __e)
687	__err \|= ios_base::eofbit;
688	return __b;
689	}	631	}
690		632
691	extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>;	633	extern template class _LIBCPP_EXTERN_TEMPLATE_TYPE_VIS num_get<char>;
...	@@ -748,6 +690,13 @@ void __num_put<_CharT>::__widen_and_group_int(	...	@@ -748,6 +690,13 @@ void __num_put<_CharT>::__widen_and_group_int(
748	__op = __ob + (__np - __nb);	690	__op = __ob + (__np - __nb);
749	}	691	}
750		692
		693	_LIBCPP_HIDE_FROM_ABI inline bool __isdigit(char __c) { return __c >= '0' && __c <= '9'; }
		694
		695	_LIBCPP_HIDE_FROM_ABI inline bool __isxdigit(char __c) {
		696	auto __lower = __c \| 0x20;
		697	return std::__isdigit(__c) \|\| (__lower >= 'a' && __lower <= 'f');
		698	}
		699
751	template <class _CharT>	700	template <class _CharT>
752	void __num_put<_CharT>::__widen_and_group_float(	701	void __num_put<_CharT>::__widen_and_group_float(
753	char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT& __op, _CharT& __oe, const locale& __loc) {	702	char* __nb, char* __np, char* __ne, _CharT* __ob, _CharT& __op, _CharT& __oe, const locale& __loc) {
...	@@ -763,11 +712,11 @@ void __num_put<_CharT>::__widen_and_group_float(	...	@@ -763,11 +712,11 @@ void __num_put<_CharT>::__widen_and_group_float(
763	__oe++ = __ct.widen(__nf++);	712	__oe++ = __ct.widen(__nf++);
764	__oe++ = __ct.widen(__nf++);	713	__oe++ = __ct.widen(__nf++);
765	for (__ns = __nf; __ns < __ne; ++__ns)	714	for (__ns = __nf; __ns < __ne; ++__ns)
766	if (!__locale::__isxdigit(*__ns, _LIBCPP_GET_C_LOCALE))	715	if (!std::__isxdigit(*__ns))
767	break;	716	break;
768	} else {	717	} else {
769	for (__ns = __nf; __ns < __ne; ++__ns)	718	for (__ns = __nf; __ns < __ne; ++__ns)
770	if (!__locale::__isdigit(*__ns, _LIBCPP_GET_C_LOCALE))	719	if (!std::__isdigit(*__ns))
771	break;	720	break;
772	}	721	}
773	if (__grouping.empty()) {	722	if (__grouping.empty()) {
...	@@ -885,9 +834,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_ty	...	@@ -885,9 +834,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob, char_ty
885	const numpunct<char_type>& __np = std::use_facet<numpunct<char_type> >(__iob.getloc());	834	const numpunct<char_type>& __np = std::use_facet<numpunct<char_type> >(__iob.getloc());
886	typedef typename numpunct<char_type>::string_type string_type;	835	typedef typename numpunct<char_type>::string_type string_type;
887	string_type __nm = __v ? __np.truename() : __np.falsename();	836	string_type __nm = __v ? __np.truename() : __np.falsename();
888	for (typename string_type::iterator __i = __nm.begin(); __i != __nm.end(); ++__i, ++__s)	837	return std::copy(__nm.begin(), __nm.end(), __s);
889	__s = __i;
890	return __s;
891	}	838	}
892		839
893	template <class _CharT, class _OutputIterator>	840	template <class _CharT, class _OutputIterator>

lib/libcxx/include/__locale_dir/pad_and_output.h+5-6

 @@ -13,6 +13,8 @@
 #if _LIBCPP_HAS_LOCALIZATION
+#  include <__algorithm/copy.h>
+#  include <__algorithm/fill_n.h>
 #  include <ios>
 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 @@ -30,12 +32,9 @@ _LIBCPP_HIDE_FROM_ABI _OutputIterator __pad_and_output(
     __ns -= __sz;
   else
     __ns = 0;
-  for (; __ob < __op; ++__ob, ++__s)
+  __s = std::copy(__ob, __op, __s);
-    *__s = *__ob;
+  __s = std::fill_n(__s, __ns, __fl);
-  for (; __ns; --__ns, ++__s)
+  __s = std::copy(__op, __oe, __s);
-    *__s = __fl;
-  for (; __ob < __oe; ++__ob, ++__s)
-    *__s = *__ob;
   __iob.width(0);
   return __s;
 }

lib/libcxx/include/__locale_dir/support/bsd_like.h-20

...	@@ -24,7 +24,6 @@	...	@@ -24,7 +24,6 @@
24	# include <wctype.h>	24	# include <wctype.h>
25	#endif	25	#endif
26		26
27	/* zig patch: https://github.com/llvm/llvm-project/pull/143055 */
28	#if __has_include(<xlocale.h>)	27	#if __has_include(<xlocale.h>)
29	# include <xlocale.h>	28	# include <xlocale.h>
30	#endif	29	#endif
...	@@ -80,22 +79,9 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __	...	@@ -80,22 +79,9 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __
80	return ::strtold_l(__nptr, __endptr, __loc);	79	return ::strtold_l(__nptr, __endptr, __loc);
81	}	80	}
82		81
83	inline _LIBCPP_HIDE_FROM_ABI long long __strtoll(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
84	return ::strtoll_l(__nptr, __endptr, __base, __loc);
85	}
86
87	inline _LIBCPP_HIDE_FROM_ABI unsigned long long
88	__strtoull(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
89	return ::strtoull_l(__nptr, __endptr, __base, __loc);
90	}
91
92	//	82	//
93	// Character manipulation functions	83	// Character manipulation functions
94	//	84	//
95	inline _LIBCPP_HIDE_FROM_ABI int __isdigit(int __c, __locale_t __loc) { return ::isdigit_l(__c, __loc); }
96
97	inline _LIBCPP_HIDE_FROM_ABI int __isxdigit(int __c, __locale_t __loc) { return ::isxdigit_l(__c, __loc); }
98
99	#if defined(_LIBCPP_BUILDING_LIBRARY)	85	#if defined(_LIBCPP_BUILDING_LIBRARY)
100	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return ::toupper_l(__c, __loc); }	86	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return ::toupper_l(__c, __loc); }
101		87
...	@@ -216,12 +202,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __	...	@@ -216,12 +202,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __
216	char** __s, __locale_t __loc, const char* __format, _Args&&... __args) {	202	char** __s, __locale_t __loc, const char* __format, _Args&&... __args) {
217	return ::asprintf_l(__s, __loc, __format, std::forward<_Args>(__args)...); // non-standard	203	return ::asprintf_l(__s, __loc, __format, std::forward<_Args>(__args)...); // non-standard
218	}	204	}
219
220	template <class... _Args>
221	_LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __sscanf(
222	const char* __s, __locale_t __loc, const char* __format, _Args&&... __args) {
223	return ::sscanf_l(__s, __loc, __format, std::forward<_Args>(__args)...);
224	}
225	_LIBCPP_DIAGNOSTIC_POP	205	_LIBCPP_DIAGNOSTIC_POP
226	#undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT	206	#undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT
227		207

lib/libcxx/include/__locale_dir/support/fuchsia.h-7

...	@@ -141,13 +141,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __	...	@@ -141,13 +141,6 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __
141	__locale_guard __current(__loc);	141	__locale_guard __current(__loc);
142	return ::asprintf(__s, __format, std::forward<_Args>(__args)...); // non-standard	142	return ::asprintf(__s, __format, std::forward<_Args>(__args)...); // non-standard
143	}	143	}
144	template <class... _Args>
145	_LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __sscanf(
146	const char* __s, __locale_t __loc, const char* __format, _Args&&... __args) {
147	__locale_guard __current(__loc);
148	return std::sscanf(__s, __format, std::forward<_Args>(__args)...);
149	}
150
151	_LIBCPP_DIAGNOSTIC_POP	144	_LIBCPP_DIAGNOSTIC_POP
152	#undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT	145	#undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT
153		146

lib/libcxx/include/__locale_dir/support/linux.h-37

...	@@ -94,32 +94,9 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __	...	@@ -94,32 +94,9 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __
94	return ::strtold_l(__nptr, __endptr, __loc);	94	return ::strtold_l(__nptr, __endptr, __loc);
95	}	95	}
96		96
97	inline _LIBCPP_HIDE_FROM_ABI long long __strtoll(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
98	#if !_LIBCPP_HAS_MUSL_LIBC
99	return ::strtoll_l(__nptr, __endptr, __base, __loc);
100	#else
101	(void)__loc;
102	return ::strtoll(__nptr, __endptr, __base);
103	#endif
104	}
105
106	inline _LIBCPP_HIDE_FROM_ABI unsigned long long
107	__strtoull(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
108	#if !_LIBCPP_HAS_MUSL_LIBC
109	return ::strtoull_l(__nptr, __endptr, __base, __loc);
110	#else
111	(void)__loc;
112	return ::strtoull(__nptr, __endptr, __base);
113	#endif
114	}
115
116	//	97	//
117	// Character manipulation functions	98	// Character manipulation functions
118	//	99	//
119	inline _LIBCPP_HIDE_FROM_ABI int __isdigit(int __c, __locale_t __loc) { return isdigit_l(__c, __loc); }
120
121	inline _LIBCPP_HIDE_FROM_ABI int __isxdigit(int __c, __locale_t __loc) { return isxdigit_l(__c, __loc); }
122
123	#if defined(_LIBCPP_BUILDING_LIBRARY)	100	#if defined(_LIBCPP_BUILDING_LIBRARY)
124	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return toupper_l(__c, __loc); }	101	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return toupper_l(__c, __loc); }
125		102
...	@@ -261,20 +238,6 @@ inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __asprintf(	...	@@ -261,20 +238,6 @@ inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __asprintf(
261	va_end(__va);	238	va_end(__va);
262	return __res;	239	return __res;
263	}	240	}
264
265	#ifndef _LIBCPP_COMPILER_GCC // GCC complains that this can't be always_inline due to C-style varargs
266	_LIBCPP_HIDE_FROM_ABI
267	#endif
268	inline _LIBCPP_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __sscanf(
269	const char* __s, __locale_t __loc, const char* __format, ...) {
270	va_list __va;
271	va_start(__va, __format);
272	__locale_guard __current(__loc);
273	int __res = std::vsscanf(__s, __format, __va);
274	va_end(__va);
275	return __res;
276	}
277
278	} // namespace __locale	241	} // namespace __locale
279	_LIBCPP_END_NAMESPACE_STD	242	_LIBCPP_END_NAMESPACE_STD
280		243

lib/libcxx/include/__locale_dir/support/netbsd.h-2

...	@@ -6,8 +6,6 @@	...	@@ -6,8 +6,6 @@
6	//	6	//
7	//===----------------------------------------------------------------------===//	7	//===----------------------------------------------------------------------===//
8		8
9	/* zig patch: https://github.com/llvm/llvm-project/pull/143055 */
10
11	#ifndef _LIBCPP___LOCALE_DIR_SUPPORT_NETBSD_H	9	#ifndef _LIBCPP___LOCALE_DIR_SUPPORT_NETBSD_H
12	#define _LIBCPP___LOCALE_DIR_SUPPORT_NETBSD_H	10	#define _LIBCPP___LOCALE_DIR_SUPPORT_NETBSD_H
13		11

lib/libcxx/include/__locale_dir/support/newlib.h created+243

...	@@ -0,0 +1,243 @@
1	//===-----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___LOCALE_DIR_SUPPORT_NEWLIB_H
10	#define _LIBCPP___LOCALE_DIR_SUPPORT_NEWLIB_H
11
12	#include <__config>
13	#include <__cstddef/size_t.h>
14	#include <__std_mbstate_t.h>
15	#include <clocale> // std::lconv
16	#include <cstdio>
17	#include <cstdlib>
18	#include <ctype.h>
19	#include <stdarg.h>
20	#include <string.h>
21	#include <time.h>
22	#if _LIBCPP_HAS_WIDE_CHARACTERS
23	# include <cwchar>
24	# include <wctype.h>
25	#endif
26
27	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
28	# pragma GCC system_header
29	#endif
30
31	_LIBCPP_BEGIN_NAMESPACE_STD
32	namespace __locale {
33
34	struct __locale_guard {
35	_LIBCPP_HIDE_FROM_ABI __locale_guard(locale_t& __loc) : __old_loc_(::uselocale(__loc)) {}
36
37	_LIBCPP_HIDE_FROM_ABI ~__locale_guard() {
38	if (__old_loc_)
39	::uselocale(__old_loc_);
40	}
41
42	locale_t __old_loc_;
43
44	__locale_guard(__locale_guard const&) = delete;
45	__locale_guard& operator=(__locale_guard const&) = delete;
46	};
47
48	//
49	// Locale management
50	//
51	#define _LIBCPP_COLLATE_MASK LC_COLLATE_MASK
52	#define _LIBCPP_CTYPE_MASK LC_CTYPE_MASK
53	#define _LIBCPP_MONETARY_MASK LC_MONETARY_MASK
54	#define _LIBCPP_NUMERIC_MASK LC_NUMERIC_MASK
55	#define _LIBCPP_TIME_MASK LC_TIME_MASK
56	#define _LIBCPP_MESSAGES_MASK LC_MESSAGES_MASK
57	#define _LIBCPP_ALL_MASK LC_ALL_MASK
58	#define _LIBCPP_LC_ALL LC_ALL
59
60	using __locale_t _LIBCPP_NODEBUG = ::locale_t;
61
62	#if defined(_LIBCPP_BUILDING_LIBRARY)
63	using __lconv_t _LIBCPP_NODEBUG = std::lconv;
64
65	inline _LIBCPP_HIDE_FROM_ABI __locale_t __newlocale(int __category_mask, const char* __locale, __locale_t __base) {
66	return ::newlocale(__category_mask, __locale, __base);
67	}
68
69	inline _LIBCPP_HIDE_FROM_ABI void __freelocale(__locale_t __loc) { ::freelocale(__loc); }
70
71	inline _LIBCPP_HIDE_FROM_ABI char* __setlocale(int __category, char const* __locale) {
72	return ::setlocale(__category, __locale);
73	}
74
75	inline _LIBCPP_HIDE_FROM_ABI __lconv_t* __localeconv(__locale_t& __loc) {
76	__locale_guard __current(__loc);
77	return std::localeconv();
78	}
79	#endif // _LIBCPP_BUILDING_LIBRARY
80
81	//
82	// Strtonum functions
83	//
84	inline _LIBCPP_HIDE_FROM_ABI float __strtof(const char* __nptr, char** __endptr, __locale_t __loc) {
85	return ::strtof_l(__nptr, __endptr, __loc);
86	}
87
88	inline _LIBCPP_HIDE_FROM_ABI double __strtod(const char* __nptr, char** __endptr, __locale_t __loc) {
89	return ::strtod_l(__nptr, __endptr, __loc);
90	}
91
92	inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __endptr, __locale_t __loc) {
93	return ::strtold_l(__nptr, __endptr, __loc);
94	}
95
96	//
97	// Character manipulation functions
98	//
99	#if defined(_LIBCPP_BUILDING_LIBRARY)
100	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return toupper_l(__c, __loc); }
101
102	inline _LIBCPP_HIDE_FROM_ABI int __tolower(int __c, __locale_t __loc) { return tolower_l(__c, __loc); }
103
104	inline _LIBCPP_HIDE_FROM_ABI int __strcoll(const char* __s1, const char* __s2, __locale_t __loc) {
105	return strcoll_l(__s1, __s2, __loc);
106	}
107
108	inline _LIBCPP_HIDE_FROM_ABI size_t __strxfrm(char* __dest, const char* __src, size_t __n, __locale_t __loc) {
109	return strxfrm_l(__dest, __src, __n, __loc);
110	}
111
112	# if _LIBCPP_HAS_WIDE_CHARACTERS
113	inline _LIBCPP_HIDE_FROM_ABI int __iswctype(wint_t __c, wctype_t __type, __locale_t __loc) {
114	return iswctype_l(__c, __type, __loc);
115	}
116
117	inline _LIBCPP_HIDE_FROM_ABI int __iswspace(wint_t __c, __locale_t __loc) { return iswspace_l(__c, __loc); }
118
119	inline _LIBCPP_HIDE_FROM_ABI int __iswprint(wint_t __c, __locale_t __loc) { return iswprint_l(__c, __loc); }
120
121	inline _LIBCPP_HIDE_FROM_ABI int __iswcntrl(wint_t __c, __locale_t __loc) { return iswcntrl_l(__c, __loc); }
122
123	inline _LIBCPP_HIDE_FROM_ABI int __iswupper(wint_t __c, __locale_t __loc) { return iswupper_l(__c, __loc); }
124
125	inline _LIBCPP_HIDE_FROM_ABI int __iswlower(wint_t __c, __locale_t __loc) { return iswlower_l(__c, __loc); }
126
127	inline _LIBCPP_HIDE_FROM_ABI int __iswalpha(wint_t __c, __locale_t __loc) { return iswalpha_l(__c, __loc); }
128
129	inline _LIBCPP_HIDE_FROM_ABI int __iswblank(wint_t __c, __locale_t __loc) { return iswblank_l(__c, __loc); }
130
131	inline _LIBCPP_HIDE_FROM_ABI int __iswdigit(wint_t __c, __locale_t __loc) { return iswdigit_l(__c, __loc); }
132
133	inline _LIBCPP_HIDE_FROM_ABI int __iswpunct(wint_t __c, __locale_t __loc) { return iswpunct_l(__c, __loc); }
134
135	inline _LIBCPP_HIDE_FROM_ABI int __iswxdigit(wint_t __c, __locale_t __loc) { return iswxdigit_l(__c, __loc); }
136
137	inline _LIBCPP_HIDE_FROM_ABI wint_t __towupper(wint_t __c, __locale_t __loc) { return towupper_l(__c, __loc); }
138
139	inline _LIBCPP_HIDE_FROM_ABI wint_t __towlower(wint_t __c, __locale_t __loc) { return towlower_l(__c, __loc); }
140
141	inline _LIBCPP_HIDE_FROM_ABI int __wcscoll(const wchar_t* __ws1, const wchar_t* __ws2, __locale_t __loc) {
142	return wcscoll_l(__ws1, __ws2, __loc);
143	}
144
145	inline _LIBCPP_HIDE_FROM_ABI size_t __wcsxfrm(wchar_t* __dest, const wchar_t* __src, size_t __n, __locale_t __loc) {
146	return wcsxfrm_l(__dest, __src, __n, __loc);
147	}
148	# endif // _LIBCPP_HAS_WIDE_CHARACTERS
149
150	inline _LIBCPP_HIDE_FROM_ABI
151	size_t __strftime(char* __s, size_t __max, const char* __format, const struct tm* __tm, __locale_t __loc) {
152	return strftime_l(__s, __max, __format, __tm, __loc);
153	}
154
155	//
156	// Other functions
157	//
158	inline _LIBCPP_HIDE_FROM_ABI decltype(MB_CUR_MAX) __mb_len_max(__locale_t __loc) {
159	__locale_guard __current(__loc);
160	return MB_CUR_MAX;
161	}
162
163	# if _LIBCPP_HAS_WIDE_CHARACTERS
164	inline _LIBCPP_HIDE_FROM_ABI wint_t __btowc(int __c, __locale_t __loc) {
165	__locale_guard __current(__loc);
166	return std::btowc(__c);
167	}
168
169	inline _LIBCPP_HIDE_FROM_ABI int __wctob(wint_t __c, __locale_t __loc) {
170	__locale_guard __current(__loc);
171	return std::wctob(__c);
172	}
173
174	inline _LIBCPP_HIDE_FROM_ABI size_t
175	__wcsnrtombs(char* __dest, const wchar_t** __src, size_t __nwc, size_t __len, mbstate_t* __ps, __locale_t __loc) {
176	__locale_guard __current(__loc);
177	return ::wcsnrtombs(__dest, __src, __nwc, __len, __ps); // non-standard
178	}
179
180	inline _LIBCPP_HIDE_FROM_ABI size_t __wcrtomb(char* __s, wchar_t __wc, mbstate_t* __ps, __locale_t __loc) {
181	__locale_guard __current(__loc);
182	return std::wcrtomb(__s, __wc, __ps);
183	}
184
185	inline _LIBCPP_HIDE_FROM_ABI size_t
186	__mbsnrtowcs(wchar_t* __dest, const char** __src, size_t __nms, size_t __len, mbstate_t* __ps, __locale_t __loc) {
187	__locale_guard __current(__loc);
188	return ::mbsnrtowcs(__dest, __src, __nms, __len, __ps); // non-standard
189	}
190
191	inline _LIBCPP_HIDE_FROM_ABI size_t
192	__mbrtowc(wchar_t* __pwc, const char* __s, size_t __n, mbstate_t* __ps, __locale_t __loc) {
193	__locale_guard __current(__loc);
194	return std::mbrtowc(__pwc, __s, __n, __ps);
195	}
196
197	inline _LIBCPP_HIDE_FROM_ABI int __mbtowc(wchar_t* __pwc, const char* __pmb, size_t __max, __locale_t __loc) {
198	__locale_guard __current(__loc);
199	return std::mbtowc(__pwc, __pmb, __max);
200	}
201
202	inline _LIBCPP_HIDE_FROM_ABI size_t __mbrlen(const char* __s, size_t __n, mbstate_t* __ps, __locale_t __loc) {
203	__locale_guard __current(__loc);
204	return std::mbrlen(__s, __n, __ps);
205	}
206
207	inline _LIBCPP_HIDE_FROM_ABI size_t
208	__mbsrtowcs(wchar_t* __dest, const char** __src, size_t __len, mbstate_t* __ps, __locale_t __loc) {
209	__locale_guard __current(__loc);
210	return std::mbsrtowcs(__dest, __src, __len, __ps);
211	}
212	# endif // _LIBCPP_HAS_WIDE_CHARACTERS
213	#endif // _LIBCPP_BUILDING_LIBRARY
214
215	#ifndef _LIBCPP_COMPILER_GCC // GCC complains that this can't be always_inline due to C-style varargs
216	_LIBCPP_HIDE_FROM_ABI
217	#endif
218	inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 4, 5) int __snprintf(
219	char* __s, size_t __n, __locale_t __loc, const char* __format, ...) {
220	va_list __va;
221	va_start(__va, __format);
222	__locale_guard __current(__loc);
223	int __res = std::vsnprintf(__s, __n, __format, __va);
224	va_end(__va);
225	return __res;
226	}
227
228	#ifndef _LIBCPP_COMPILER_GCC // GCC complains that this can't be always_inline due to C-style varargs
229	_LIBCPP_HIDE_FROM_ABI
230	#endif
231	inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __asprintf(
232	char** __s, __locale_t __loc, const char* __format, ...) {
233	va_list __va;
234	va_start(__va, __format);
235	__locale_guard __current(__loc);
236	int __res = ::vasprintf(__s, __format, __va); // non-standard
237	va_end(__va);
238	return __res;
239	}
240	} // namespace __locale
241	_LIBCPP_END_NAMESPACE_STD
242
243	#endif // _LIBCPP___LOCALE_DIR_SUPPORT_NEWLIB_H

lib/libcxx/include/__locale_dir/support/no_locale/characters.h-4

 @@ -29,10 +29,6 @@ namespace __locale {
 //
 // Character manipulation functions
 //
-inline _LIBCPP_HIDE_FROM_ABI int __isdigit(int __c, __locale_t) { return std::isdigit(__c); }
-inline _LIBCPP_HIDE_FROM_ABI int __isxdigit(int __c, __locale_t) { return std::isxdigit(__c); }
 #if defined(_LIBCPP_BUILDING_LIBRARY)
 inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t) { return std::toupper(__c); }

lib/libcxx/include/__locale_dir/support/no_locale/strtonum.h-9

...	@@ -34,15 +34,6 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __	...	@@ -34,15 +34,6 @@ inline _LIBCPP_HIDE_FROM_ABI long double __strtold(const char* __nptr, char** __
34	return std::strtold(__nptr, __endptr);	34	return std::strtold(__nptr, __endptr);
35	}	35	}
36		36
37	inline _LIBCPP_HIDE_FROM_ABI long long __strtoll(const char* __nptr, char** __endptr, int __base, __locale_t) {
38	return std::strtoll(__nptr, __endptr, __base);
39	}
40
41	inline _LIBCPP_HIDE_FROM_ABI unsigned long long
42	__strtoull(const char* __nptr, char** __endptr, int __base, __locale_t) {
43	return std::strtoull(__nptr, __endptr, __base);
44	}
45
46	} // namespace __locale	37	} // namespace __locale
47	_LIBCPP_END_NAMESPACE_STD	38	_LIBCPP_END_NAMESPACE_STD
48		39

lib/libcxx/include/__locale_dir/support/windows.h-29

...	@@ -186,21 +186,9 @@ inline _LIBCPP_HIDE_FROM_ABI double __strtod(const char* __nptr, char** __endptr	...	@@ -186,21 +186,9 @@ inline _LIBCPP_HIDE_FROM_ABI double __strtod(const char* __nptr, char** __endptr
186	return ::_strtod_l(__nptr, __endptr, __loc);	186	return ::_strtod_l(__nptr, __endptr, __loc);
187	}	187	}
188		188
189	inline _LIBCPP_HIDE_FROM_ABI long long __strtoll(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
190	return ::_strtoi64_l(__nptr, __endptr, __base, __loc);
191	}
192	inline _LIBCPP_HIDE_FROM_ABI unsigned long long
193	__strtoull(const char* __nptr, char** __endptr, int __base, __locale_t __loc) {
194	return ::_strtoui64_l(__nptr, __endptr, __base, __loc);
195	}
196
197	//	189	//
198	// Character manipulation functions	190	// Character manipulation functions
199	//	191	//
200	inline _LIBCPP_HIDE_FROM_ABI int __isdigit(int __c, __locale_t __loc) { return _isdigit_l(__c, __loc); }
201
202	inline _LIBCPP_HIDE_FROM_ABI int __isxdigit(int __c, __locale_t __loc) { return _isxdigit_l(__c, __loc); }
203
204	#if defined(_LIBCPP_BUILDING_LIBRARY)	192	#if defined(_LIBCPP_BUILDING_LIBRARY)
205	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return ::_toupper_l(__c, __loc); }	193	inline _LIBCPP_HIDE_FROM_ABI int __toupper(int __c, __locale_t __loc) { return ::_toupper_l(__c, __loc); }
206		194
...	@@ -280,23 +268,6 @@ _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 4, 5) int __snpri	...	@@ -280,23 +268,6 @@ _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 4, 5) int __snpri
280	_LIBCPP_EXPORTED_FROM_ABI	268	_LIBCPP_EXPORTED_FROM_ABI
281	_LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __asprintf(char** __ret, __locale_t __loc, const char* __format, ...);	269	_LIBCPP_ATTRIBUTE_FORMAT(__printf__, 3, 4) int __asprintf(char** __ret, __locale_t __loc, const char* __format, ...);
282		270
283	_LIBCPP_DIAGNOSTIC_PUSH
284	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wgcc-compat")
285	_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wformat-nonliteral") // GCC doesn't support [[gnu::format]] on variadic templates
286	#ifdef _LIBCPP_COMPILER_CLANG_BASED
287	# define _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(...) _LIBCPP_ATTRIBUTE_FORMAT(__VA_ARGS__)
288	#else
289	# define _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(...) /* nothing */
290	#endif
291
292	template <class... _Args>
293	_LIBCPP_HIDE_FROM_ABI _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT(__scanf__, 3, 4) int __sscanf(
294	const char* __dest, __locale_t __loc, const char* __format, _Args&&... __args) {
295	return ::_sscanf_l(__dest, __format, __loc, std::forward<_Args>(__args)...);
296	}
297	_LIBCPP_DIAGNOSTIC_POP
298	#undef _LIBCPP_VARIADIC_ATTRIBUTE_FORMAT
299
300	#if defined(_LIBCPP_BUILDING_LIBRARY)	271	#if defined(_LIBCPP_BUILDING_LIBRARY)
301	struct __locale_guard {	272	struct __locale_guard {
302	_LIBCPP_HIDE_FROM_ABI __locale_guard(__locale_t __l) : __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {	273	_LIBCPP_HIDE_FROM_ABI __locale_guard(__locale_t __l) : __status(_configthreadlocale(_ENABLE_PER_THREAD_LOCALE)) {

lib/libcxx/include/__locale_dir/time.h+3-7

 @@ -601,17 +601,13 @@ private:
     template <>                                                                                                        \
     _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);                           \
     template <>                                                                                                        \
-    _LIBCPP_EXPORTED_FROM_ABI void __time_get_storage<_CharT>::init(const ctype<_CharT>&);                             \
+    void __time_get_storage<_CharT>::init(const ctype<_CharT>&);                                                       \
     template <>                                                                                                        \
-    _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(           \
+    __time_get_storage<_CharT>::string_type __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&);         \
-        char, const ctype<_CharT>&);                                                                                   \
     extern template _LIBCPP_EXPORTED_FROM_ABI time_base::dateorder __time_get_storage<_CharT>::__do_date_order()       \
         const;                                                                                                         \
     extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const char*);             \
-    extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);           \
+    extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::__time_get_storage(const string&);
-    extern template _LIBCPP_EXPORTED_FROM_ABI void __time_get_storage<_CharT>::init(const ctype<_CharT>&);             \
-    extern template _LIBCPP_EXPORTED_FROM_ABI __time_get_storage<_CharT>::string_type                                  \
-    __time_get_storage<_CharT>::__analyze(char, const ctype<_CharT>&);
 _LIBCPP_TIME_GET_STORAGE_EXPLICIT_INSTANTIATION(char)
 #  if _LIBCPP_HAS_WIDE_CHARACTERS

lib/libcxx/include/__math/hypot.h+1-1

...	@@ -53,7 +53,7 @@ inline _LIBCPP_HIDE_FROM_ABI __promote_t<_A1, _A2> hypot(_A1 __x, _A2 __y) _NOEX	...	@@ -53,7 +53,7 @@ inline _LIBCPP_HIDE_FROM_ABI __promote_t<_A1, _A2> hypot(_A1 __x, _A2 __y) _NOEX
53	// Computes the three-dimensional hypotenuse: `std::hypot(x,y,z)`.	53	// Computes the three-dimensional hypotenuse: `std::hypot(x,y,z)`.
54	// The naive implementation might over-/underflow which is why this implementation is more involved:	54	// The naive implementation might over-/underflow which is why this implementation is more involved:
55	// If the square of an argument might run into issues, we scale the arguments appropriately.	55	// If the square of an argument might run into issues, we scale the arguments appropriately.
56	// See https://github.com/llvm/llvm-project/issues/92782 for a detailed discussion and summary.	56	// See https://llvm.org/PR92782 for a detailed discussion and summary.
57	template <class _Real>	57	template <class _Real>
58	_LIBCPP_HIDE_FROM_ABI _Real __hypot(_Real __x, _Real __y, _Real __z) {	58	_LIBCPP_HIDE_FROM_ABI _Real __hypot(_Real __x, _Real __y, _Real __z) {
59	// Factors needed to determine if over-/underflow might happen	59	// Factors needed to determine if over-/underflow might happen

lib/libcxx/include/__math/logarithms.h+1-1

...	@@ -58,7 +58,7 @@ inline _LIBCPP_HIDE_FROM_ABI double log10(_A1 __x) _NOEXCEPT {	...	@@ -58,7 +58,7 @@ inline _LIBCPP_HIDE_FROM_ABI double log10(_A1 __x) _NOEXCEPT {
58	inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT { return __builtin_ilogbf(__x); }	58	inline _LIBCPP_HIDE_FROM_ABI int ilogb(float __x) _NOEXCEPT { return __builtin_ilogbf(__x); }
59		59
60	template <class = int>	60	template <class = int>
61	_LIBCPP_HIDE_FROM_ABI double ilogb(double __x) _NOEXCEPT {	61	_LIBCPP_HIDE_FROM_ABI int ilogb(double __x) _NOEXCEPT {
62	return __builtin_ilogb(__x);	62	return __builtin_ilogb(__x);
63	}	63	}
64		64

lib/libcxx/include/__math/traits.h+80-11

...	@@ -25,33 +25,26 @@ namespace __math {	...	@@ -25,33 +25,26 @@ namespace __math {
25		25
26	// signbit	26	// signbit
27		27
28	// TODO(LLVM 22): Remove conditional once support for Clang 19 is dropped.
29	#if defined(_LIBCPP_COMPILER_GCC) \|\| __has_constexpr_builtin(__builtin_signbit)
30	# define _LIBCPP_SIGNBIT_CONSTEXPR _LIBCPP_CONSTEXPR_SINCE_CXX23
31	#else
32	# define _LIBCPP_SIGNBIT_CONSTEXPR
33	#endif
34
35	// The universal C runtime (UCRT) in the WinSDK provides floating point overloads	28	// The universal C runtime (UCRT) in the WinSDK provides floating point overloads
36	// for std::signbit(). By defining our overloads as templates, we can work around	29	// for std::signbit(). By defining our overloads as templates, we can work around
37	// this issue as templates are less preferred than non-template functions.	30	// this issue as templates are less preferred than non-template functions.
38	template <class = void>	31	template <class = void>
39	[[__nodiscard__]] inline _LIBCPP_SIGNBIT_CONSTEXPR _LIBCPP_HIDE_FROM_ABI bool signbit(float __x) _NOEXCEPT {	32	[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool signbit(float __x) _NOEXCEPT {
40	return __builtin_signbit(__x);	33	return __builtin_signbit(__x);
41	}	34	}
42		35
43	template <class = void>	36	template <class = void>
44	[[__nodiscard__]] inline _LIBCPP_SIGNBIT_CONSTEXPR _LIBCPP_HIDE_FROM_ABI bool signbit(double __x) _NOEXCEPT {	37	[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool signbit(double __x) _NOEXCEPT {
45	return __builtin_signbit(__x);	38	return __builtin_signbit(__x);
46	}	39	}
47		40
48	template <class = void>	41	template <class = void>
49	[[__nodiscard__]] inline _LIBCPP_SIGNBIT_CONSTEXPR _LIBCPP_HIDE_FROM_ABI bool signbit(long double __x) _NOEXCEPT {	42	[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool signbit(long double __x) _NOEXCEPT {
50	return __builtin_signbit(__x);	43	return __builtin_signbit(__x);
51	}	44	}
52		45
53	template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>	46	template <class _A1, __enable_if_t<is_integral<_A1>::value, int> = 0>
54	[[__nodiscard__]] inline _LIBCPP_SIGNBIT_CONSTEXPR _LIBCPP_HIDE_FROM_ABI bool signbit(_A1 __x) _NOEXCEPT {	47	[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool signbit(_A1 __x) _NOEXCEPT {
55	return __x < 0;	48	return __x < 0;
56	}	49	}
57		50
...	@@ -189,6 +182,82 @@ template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_ar	...	@@ -189,6 +182,82 @@ template <class _A1, class _A2, __enable_if_t<is_arithmetic<_A1>::value && is_ar
189	return __builtin_isunordered((type)__x, (type)__y);	182	return __builtin_isunordered((type)__x, (type)__y);
190	}	183	}
191		184
		185	// MS UCRT incorrectly defines some functions in a way not working with integer types. Until C++20, this was worked
		186	// around by -fdelayed-template-parsing. Since C++20, we can use standard feature "requires" instead.
		187
		188	// TODO: Remove the workaround once UCRT fixes these functions. Note that this doesn't seem planned as of 2025-07 per
		189	// https://developercommunity.visualstudio.com/t/10294165.
		190
		191	#if defined(_LIBCPP_MSVCRT) && _LIBCPP_STD_VER >= 20
		192	namespace __ucrt {
		193	template <class _A1>
		194	requires is_integral_v<_A1>
		195	[[nodiscard]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isfinite(_A1) noexcept {
		196	return true;
		197	}
		198
		199	template <class _A1>
		200	requires is_integral_v<_A1>
		201	[[nodiscard]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isinf(_A1) noexcept {
		202	return false;
		203	}
		204
		205	template <class _A1>
		206	requires is_integral_v<_A1>
		207	[[nodiscard]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnan(_A1) noexcept {
		208	return false;
		209	}
		210
		211	template <class _A1>
		212	requires is_integral_v<_A1>
		213	[[nodiscard]] inline _LIBCPP_CONSTEXPR_SINCE_CXX23 _LIBCPP_HIDE_FROM_ABI bool isnormal(_A1 __x) noexcept {
		214	return __x != 0;
		215	}
		216
		217	template <class _A1, class _A2>
		218	requires is_arithmetic_v<_A1> && is_arithmetic_v<_A2>
		219	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool isgreater(_A1 __x, _A2 __y) noexcept {
		220	using type = __promote_t<_A1, _A2>;
		221	return __builtin_isgreater((type)__x, (type)__y);
		222	}
		223
		224	template <class _A1, class _A2>
		225	requires is_arithmetic_v<_A1> && is_arithmetic_v<_A2>
		226	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool isgreaterequal(_A1 __x, _A2 __y) noexcept {
		227	using type = __promote_t<_A1, _A2>;
		228	return __builtin_isgreaterequal((type)__x, (type)__y);
		229	}
		230
		231	template <class _A1, class _A2>
		232	requires is_arithmetic_v<_A1> && is_arithmetic_v<_A2>
		233	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool isless(_A1 __x, _A2 __y) noexcept {
		234	using type = __promote_t<_A1, _A2>;
		235	return __builtin_isless((type)__x, (type)__y);
		236	}
		237
		238	template <class _A1, class _A2>
		239	requires is_arithmetic_v<_A1> && is_arithmetic_v<_A2>
		240	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool islessequal(_A1 __x, _A2 __y) noexcept {
		241	using type = __promote_t<_A1, _A2>;
		242	return __builtin_islessequal((type)__x, (type)__y);
		243	}
		244
		245	template <class _A1, class _A2>
		246	requires is_arithmetic_v<_A1> && is_arithmetic_v<_A2>
		247	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool islessgreater(_A1 __x, _A2 __y) noexcept {
		248	using type = __promote_t<_A1, _A2>;
		249	return __builtin_islessgreater((type)__x, (type)__y);
		250	}
		251
		252	template <class _A1, class _A2>
		253	requires is_arithmetic_v<_A1> && is_arithmetic_v<_A2>
		254	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool isunordered(_A1 __x, _A2 __y) noexcept {
		255	using type = __promote_t<_A1, _A2>;
		256	return __builtin_isunordered((type)__x, (type)__y);
		257	}
		258	} // namespace __ucrt
		259	#endif
		260
192	} // namespace __math	261	} // namespace __math
193		262
194	_LIBCPP_END_NAMESPACE_STD	263	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__mdspan/extents.h+7-4

 @@ -25,6 +25,7 @@
 #include <__type_traits/integer_traits.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_nothrow_constructible.h>
+#include <__type_traits/is_signed.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/integer_sequence.h>
 #include <__utility/unreachable.h>
 @@ -298,11 +299,13 @@ private:
 public:
   // [mdspan.extents.obs], observers of multidimensional index space
-  _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return __rank_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return __rank_; }
-  _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept { return __rank_dynamic_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept { return __rank_dynamic_; }
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept { return __vals_.__value(__r); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept {
-  _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
+    return __vals_.__value(__r);
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
     return _Values::__static_value(__r);
   }

lib/libcxx/include/__mdspan/layout_stride.h+4-5

...	@@ -272,11 +272,10 @@ public:	...	@@ -272,11 +272,10 @@ public:
272	return [&]<size_t... _Pos>(index_sequence<_Pos...>) {	272	return [&]<size_t... _Pos>(index_sequence<_Pos...>) {
273	if ((__extents_.extent(_Pos) * ... * 1) == 0)	273	if ((__extents_.extent(_Pos) * ... * 1) == 0)
274	return static_cast<index_type>(0);	274	return static_cast<index_type>(0);
275	else	275
276	return static_cast<index_type>(	276	return static_cast<index_type>(
277	static_cast<index_type>(1) +	277	static_cast<index_type>(1) + (((__extents_.extent(_Pos) - static_cast<index_type>(1)) * __strides_[_Pos]) +
278	(((__extents_.extent(_Pos) - static_cast<index_type>(1)) * __strides_[_Pos]) + ... +	278	... + static_cast<index_type>(0)));
279	static_cast<index_type>(0)));
280	}(make_index_sequence<__rank_>());	279	}(make_index_sequence<__rank_>());
281	}	280	}
282	}	281	}

lib/libcxx/include/__mdspan/mdspan.h+29-23

 @@ -87,16 +87,17 @@ public:
   using data_handle_type = typename accessor_type::data_handle_type;
   using reference        = typename accessor_type::reference;
-  _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return extents_type::rank(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank() noexcept { return extents_type::rank(); }
-  _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept { return extents_type::rank_dynamic(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr rank_type rank_dynamic() noexcept {
-  _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
+    return extents_type::rank_dynamic();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr size_t static_extent(rank_type __r) noexcept {
     return extents_type::static_extent(__r);
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr index_type extent(rank_type __r) const noexcept {
     return __map_.extents().extent(__r);
-  };
+  }
-public:
   //--------------------------------------------------------------------------------
   // [mdspan.mdspan.cons], mdspan constructors, assignment, and destructor
 @@ -185,7 +186,7 @@ public:
     requires((is_convertible_v<_OtherIndexTypes, index_type> && ...) &&
              (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...) &&
              (sizeof...(_OtherIndexTypes) == rank()))
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](_OtherIndexTypes... __indices) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](_OtherIndexTypes... __indices) const {
     // Note the standard layouts would also check this, but user provided ones may not, so we
     // check the precondition here
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__mdspan_detail::__is_multidimensional_index_in(extents(), __indices...),
 @@ -196,7 +197,8 @@ public:
   template <class _OtherIndexType>
     requires(is_convertible_v<const _OtherIndexType&, index_type> &&
              is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](const array< _OtherIndexType, rank()>& __indices) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference
+  operator[](const array< _OtherIndexType, rank()>& __indices) const {
     return __acc_.access(__ptr_, [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
       return __map_(__indices[_Idxs]...);
     }(make_index_sequence<rank()>()));
 @@ -205,13 +207,13 @@ public:
   template <class _OtherIndexType>
     requires(is_convertible_v<const _OtherIndexType&, index_type> &&
              is_nothrow_constructible_v<index_type, const _OtherIndexType&>)
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](span<_OtherIndexType, rank()> __indices) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](span<_OtherIndexType, rank()> __indices) const {
     return __acc_.access(__ptr_, [&]<size_t... _Idxs>(index_sequence<_Idxs...>) {
       return __map_(__indices[_Idxs]...);
     }(make_index_sequence<rank()>()));
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept {
     // Could leave this as only checked in debug mode: semantically size() is never
     // guaranteed to be related to any accessible range
     _LIBCPP_ASSERT_UNCATEGORIZED(
 @@ -237,24 +239,28 @@ public:
     swap(__x.__acc_, __y.__acc_);
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept { return __map_.extents(); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const extents_type& extents() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI constexpr const data_handle_type& data_handle() const noexcept { return __ptr_; };
+    return __map_.extents();
-  _LIBCPP_HIDE_FROM_ABI constexpr const mapping_type& mapping() const noexcept { return __map_; };
+  }
-  _LIBCPP_HIDE_FROM_ABI constexpr const accessor_type& accessor() const noexcept { return __acc_; };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const data_handle_type& data_handle() const noexcept { return __ptr_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const mapping_type& mapping() const noexcept { return __map_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const accessor_type& accessor() const noexcept { return __acc_; }
   // per LWG-4021 "mdspan::is_always_meow() should be noexcept"
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept { return mapping_type::is_always_unique(); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_unique() noexcept {
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept {
+    return mapping_type::is_always_unique();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_exhaustive() noexcept {
     return mapping_type::is_always_exhaustive();
-  };
+  }
-  _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool is_always_strided() noexcept {
     return mapping_type::is_always_strided();
-  };
+  }
-  _LIBCPP_HIDE_FROM_ABI constexpr bool is_unique() const { return __map_.is_unique(); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool is_unique() const { return __map_.is_unique(); }
-  _LIBCPP_HIDE_FROM_ABI constexpr bool is_exhaustive() const { return __map_.is_exhaustive(); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool is_exhaustive() const { return __map_.is_exhaustive(); }
-  _LIBCPP_HIDE_FROM_ABI constexpr bool is_strided() const { return __map_.is_strided(); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool is_strided() const { return __map_.is_strided(); }
-  _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const { return __map_.stride(__r); };
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr index_type stride(rank_type __r) const { return __map_.stride(__r); }
 private:
   _LIBCPP_NO_UNIQUE_ADDRESS data_handle_type __ptr_{};

lib/libcxx/include/__memory/addressof.h+7-5

 @@ -19,7 +19,8 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Tp>
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_NO_CFI _LIBCPP_HIDE_FROM_ABI _Tp* addressof(_Tp& __x) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_NO_CFI _LIBCPP_HIDE_FROM_ABI _Tp*
+addressof(_Tp& __x) _NOEXCEPT {
   return __builtin_addressof(__x);
 }
 @@ -27,24 +28,25 @@ inline _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_NO_CFI _LIBCPP_HIDE_FROM_ABI _Tp* a
 // Objective-C++ Automatic Reference Counting uses qualified pointers
 // that require special addressof() signatures.
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI __strong _Tp* addressof(__strong _Tp& __x) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __strong _Tp* addressof(__strong _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 #  if __has_feature(objc_arc_weak)
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI __weak _Tp* addressof(__weak _Tp& __x) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __weak _Tp* addressof(__weak _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 #  endif
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI __autoreleasing _Tp* addressof(__autoreleasing _Tp& __x) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __autoreleasing _Tp* addressof(__autoreleasing _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI __unsafe_unretained _Tp* addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __unsafe_unretained _Tp*
+addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT {
   return &__x;
 }
 #endif

lib/libcxx/include/__memory/align.h+18-1

...	@@ -11,6 +11,7 @@	...	@@ -11,6 +11,7 @@
11		11
12	#include <__config>	12	#include <__config>
13	#include <__cstddef/size_t.h>	13	#include <__cstddef/size_t.h>
		14	#include <cstdint>
14		15
15	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	16	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
16	# pragma GCC system_header	17	# pragma GCC system_header
...	@@ -18,7 +19,23 @@	...	@@ -18,7 +19,23 @@
18		19
19	_LIBCPP_BEGIN_NAMESPACE_STD	20	_LIBCPP_BEGIN_NAMESPACE_STD
20		21
21	_LIBCPP_EXPORTED_FROM_ABI void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);	22	inline namespace __align_inline {
		23	_LIBCPP_HIDE_FROM_ABI inline void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space) {
		24	void* __r = nullptr;
		25	if (__sz <= __space) {
		26	char* __p1 = static_cast<char*>(__ptr);
		27	char* __p2 = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(__p1 + (__align - 1)) & -__align);
		28	size_t __d = static_cast<size_t>(__p2 - __p1);
		29	if (__d <= __space - __sz) {
		30	__r = __p2;
		31	__ptr = __r;
		32	__space -= __d;
		33	}
		34	}
		35	return __r;
		36	}
		37
		38	} // namespace __align_inline
22		39
23	_LIBCPP_END_NAMESPACE_STD	40	_LIBCPP_END_NAMESPACE_STD
24		41

lib/libcxx/include/__memory/allocate_at_least.h+15-10

 @@ -19,26 +19,31 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
+template <class _Pointer, class _SizeT = size_t>
+struct __allocation_result {
+  _Pointer ptr;
+  _SizeT count;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __allocation_result(_Pointer __ptr, _SizeT __count)
+      : ptr(__ptr), count(__count) {}
+};
+_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__allocation_result);
 #if _LIBCPP_STD_VER >= 23
 template <class _Alloc>
 [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto __allocate_at_least(_Alloc& __alloc, size_t __n) {
-  return std::allocator_traits<_Alloc>::allocate_at_least(__alloc, __n);
+  auto __res = std::allocator_traits<_Alloc>::allocate_at_least(__alloc, __n);
+  return __allocation_result{__res.ptr, __res.count};
 }
 #else
-template <class _Pointer>
+template <class _Alloc, class _Traits = allocator_traits<_Alloc> >
-struct __allocation_result {
-  _Pointer ptr;
-  size_t count;
-};
-template <class _Alloc>
 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI
-_LIBCPP_CONSTEXPR __allocation_result<typename allocator_traits<_Alloc>::pointer>
+_LIBCPP_CONSTEXPR __allocation_result<typename _Traits::pointer, typename _Traits::size_type>
 __allocate_at_least(_Alloc& __alloc, size_t __n) {
-  return {__alloc.allocate(__n), __n};
+  return __allocation_result<typename _Traits::pointer, typename _Traits::size_type>(__alloc.allocate(__n), __n);
 }
 #endif // _LIBCPP_STD_VER >= 23

lib/libcxx/include/__memory/allocator.h+14-26

 @@ -14,7 +14,6 @@
 #include <__cstddef/ptrdiff_t.h>
 #include <__cstddef/size_t.h>
 #include <__memory/addressof.h>
-#include <__memory/allocate_at_least.h>
 #include <__memory/allocator_traits.h>
 #include <__new/allocate.h>
 #include <__new/exceptions.h>
 @@ -51,33 +50,21 @@ public:
 };
 #endif // _LIBCPP_STD_VER <= 17
-// This class provides a non-trivial default constructor to the class that derives from it
+template <bool, class _Unique>
-// if the condition is satisfied.
+struct __non_trivially_default_constructible_if {};
-//
-// The second template parameter exists to allow giving a unique type to __non_trivial_if,
-// which makes it possible to avoid breaking the ABI when making this a base class of an
-// existing class. Without that, imagine we have classes D1 and D2, both of which used to
-// have no base classes, but which now derive from __non_trivial_if. The layout of a class
-// that inherits from both D1 and D2 will change because the two __non_trivial_if base
-// classes are not allowed to share the same address.
-//
-// By making those __non_trivial_if base classes unique, we work around this problem and
-// it is safe to start deriving from __non_trivial_if in existing classes.
-template <bool _Cond, class _Unique>
-struct __non_trivial_if {};
 template <class _Unique>
-struct __non_trivial_if<true, _Unique> {
+struct __non_trivially_default_constructible_if<true, _Unique> {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __non_trivial_if() _NOEXCEPT {}
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __non_trivially_default_constructible_if() {}
 };
-// allocator
-//
-// Note: For ABI compatibility between C++20 and previous standards, we make
-//       allocator<void> trivial in C++20.
 template <class _Tp>
-class allocator : private __non_trivial_if<!is_void<_Tp>::value, allocator<_Tp> > {
+class allocator
+// TODO(LLVM 24): Remove the opt-out
+#ifdef _LIBCPP_DEPRECATED_ABI_NON_TRIVIAL_ALLOCATOR
+    : __non_trivially_default_constructible_if<!is_void<_Tp>::value, allocator<_Tp> >
+#endif
+{
   static_assert(!is_const<_Tp>::value, "std::allocator does not support const types");
   static_assert(!is_volatile<_Tp>::value, "std::allocator does not support volatile types");
 @@ -133,10 +120,11 @@ public:
     typedef allocator<_Up> other;
   };
-  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI pointer address(reference __x) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI pointer address(reference __x) const _NOEXCEPT {
     return std::addressof(__x);
   }
-  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI const_pointer address(const_reference __x) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI const_pointer
+  address(const_reference __x) const _NOEXCEPT {
     return std::addressof(__x);
   }
 @@ -144,7 +132,7 @@ public:
     return allocate(__n);
   }
-  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
     return size_type(~0) / sizeof(_Tp);
   }

lib/libcxx/include/__memory/allocator_traits.h+6-4

 @@ -314,23 +314,25 @@ struct allocator_traits {
   }
   template <class _Ap = _Alloc, __enable_if_t<__has_max_size_v<const _Ap>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type max_size(const allocator_type& __a) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type
+  max_size(const allocator_type& __a) _NOEXCEPT {
     _LIBCPP_SUPPRESS_DEPRECATED_PUSH
     return __a.max_size();
     _LIBCPP_SUPPRESS_DEPRECATED_POP
   }
   template <class _Ap = _Alloc, __enable_if_t<!__has_max_size_v<const _Ap>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type max_size(const allocator_type&) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static size_type
+  max_size(const allocator_type&) _NOEXCEPT {
     return numeric_limits<size_type>::max() / sizeof(value_type);
   }
   template <class _Ap = _Alloc, __enable_if_t<__has_select_on_container_copy_construction_v<const _Ap>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static allocator_type
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static allocator_type
   select_on_container_copy_construction(const allocator_type& __a) {
     return __a.select_on_container_copy_construction();
   }
   template <class _Ap = _Alloc, __enable_if_t<!__has_select_on_container_copy_construction_v<const _Ap>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static allocator_type
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 static allocator_type
   select_on_container_copy_construction(const allocator_type& __a) {
     return __a;
   }

lib/libcxx/include/__memory/compressed_pair.h+15-9

...	@@ -28,8 +28,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -28,8 +28,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
28	// understand how it works). //	28	// understand how it works). //
29	// ================================================================================================================== //	29	// ================================================================================================================== //
30		30
31	// The first member is aligned to the alignment of the second member to force padding in front of the compressed pair	31	// On GCC, the first member is aligned to the alignment of the second member to force padding in front of the compressed
32	// in case there are members before it.	32	// pair in case there are members before it.
33	//	33	//
34	// For example:	34	// For example:
35	// (assuming x86-64 linux)	35	// (assuming x86-64 linux)
...	@@ -52,7 +52,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -52,7 +52,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
52	//	52	//
53	// Furthermore, that alignment must be the same as what was used in the old __compressed_pair layout, so we must	53	// Furthermore, that alignment must be the same as what was used in the old __compressed_pair layout, so we must
54	// handle reference types specially since alignof(T&) == alignof(T).	54	// handle reference types specially since alignof(T&) == alignof(T).
55	// See https://github.com/llvm/llvm-project/issues/118559.	55	// See https://llvm.org/PR118559.
		56	//
		57	// On Clang, this is unnecessary, since we use anonymous structs instead, which automatically handle the alignment
		58	// correctly.
56		59
57	#ifndef _LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING	60	#ifndef _LIBCPP_ABI_NO_COMPRESSED_PAIR_PADDING
58		61
...	@@ -64,7 +67,7 @@ inline const size_t __compressed_pair_alignment<_Tp&> = _LIBCPP_ALIGNOF(void*);	...	@@ -64,7 +67,7 @@ inline const size_t __compressed_pair_alignment<_Tp&> = _LIBCPP_ALIGNOF(void*);
64		67
65	template <class _ToPad>	68	template <class _ToPad>
66	inline const bool __is_reference_or_unpadded_object =	69	inline const bool __is_reference_or_unpadded_object =
67	(is_empty<_ToPad>::value && !__libcpp_is_final<_ToPad>::value) \|\| sizeof(_ToPad) == __datasizeof_v<_ToPad>;	70	(is_empty<_ToPad>::value && !__is_final_v<_ToPad>) \|\| sizeof(_ToPad) == __datasizeof_v<_ToPad>;
68		71
69	template <class _Tp>	72	template <class _Tp>
70	inline const bool __is_reference_or_unpadded_object<_Tp&> = true;	73	inline const bool __is_reference_or_unpadded_object<_Tp&> = true;
...	@@ -80,6 +83,10 @@ class __compressed_pair_padding {	...	@@ -80,6 +83,10 @@ class __compressed_pair_padding {
80	template <class _ToPad>	83	template <class _ToPad>
81	class __compressed_pair_padding<_ToPad, true> {};	84	class __compressed_pair_padding<_ToPad, true> {};
82		85
		86	# define _LIBCPP_COMPRESSED_ELEMENT(T1, Initializer1) \
		87	_LIBCPP_NO_UNIQUE_ADDRESS T1 Initializer1; \
		88	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T1> _LIBCPP_CONCAT3(__padding_, __LINE__, _)
		89
83	// TODO: Fix the ABI for GCC as well once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=121637 is fixed	90	// TODO: Fix the ABI for GCC as well once https://gcc.gnu.org/bugzilla/show_bug.cgi?id=121637 is fixed
84	# ifdef _LIBCPP_COMPILER_GCC	91	# ifdef _LIBCPP_COMPILER_GCC
85	# define _LIBCPP_COMPRESSED_PAIR(T1, Initializer1, T2, Initializer2) \	92	# define _LIBCPP_COMPRESSED_PAIR(T1, Initializer1, T2, Initializer2) \
...	@@ -100,8 +107,7 @@ class __compressed_pair_padding<_ToPad, true> {};	...	@@ -100,8 +107,7 @@ class __compressed_pair_padding<_ToPad, true> {};
100	# else	107	# else
101	# define _LIBCPP_COMPRESSED_PAIR(T1, Initializer1, T2, Initializer2) \	108	# define _LIBCPP_COMPRESSED_PAIR(T1, Initializer1, T2, Initializer2) \
102	struct { \	109	struct { \
103	_LIBCPP_NO_UNIQUE_ADDRESS \	110	_LIBCPP_NO_UNIQUE_ADDRESS T1 Initializer1; \
104	__attribute__((__aligned__(::std::__compressed_pair_alignment<T2>))) T1 Initializer1; \
105	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T1> _LIBCPP_CONCAT3(__padding1_, __LINE__, _); \	111	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T1> _LIBCPP_CONCAT3(__padding1_, __LINE__, _); \
106	_LIBCPP_NO_UNIQUE_ADDRESS T2 Initializer2; \	112	_LIBCPP_NO_UNIQUE_ADDRESS T2 Initializer2; \
107	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T2> _LIBCPP_CONCAT3(__padding2_, __LINE__, _); \	113	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T2> _LIBCPP_CONCAT3(__padding2_, __LINE__, _); \
...	@@ -109,9 +115,7 @@ class __compressed_pair_padding<_ToPad, true> {};	...	@@ -109,9 +115,7 @@ class __compressed_pair_padding<_ToPad, true> {};
109		115
110	# define _LIBCPP_COMPRESSED_TRIPLE(T1, Initializer1, T2, Initializer2, T3, Initializer3) \	116	# define _LIBCPP_COMPRESSED_TRIPLE(T1, Initializer1, T2, Initializer2, T3, Initializer3) \
111	struct { \	117	struct { \
112	_LIBCPP_NO_UNIQUE_ADDRESS \	118	_LIBCPP_NO_UNIQUE_ADDRESS T1 Initializer1; \
113	__attribute__((__aligned__(::std::__compressed_pair_alignment<T2>), \
114	__aligned__(::std::__compressed_pair_alignment<T3>))) T1 Initializer1; \
115	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T1> _LIBCPP_CONCAT3(__padding1_, __LINE__, _); \	119	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T1> _LIBCPP_CONCAT3(__padding1_, __LINE__, _); \
116	_LIBCPP_NO_UNIQUE_ADDRESS T2 Initializer2; \	120	_LIBCPP_NO_UNIQUE_ADDRESS T2 Initializer2; \
117	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T2> _LIBCPP_CONCAT3(__padding2_, __LINE__, _); \	121	_LIBCPP_NO_UNIQUE_ADDRESS ::std::__compressed_pair_padding<T2> _LIBCPP_CONCAT3(__padding2_, __LINE__, _); \
...	@@ -121,6 +125,8 @@ class __compressed_pair_padding<_ToPad, true> {};	...	@@ -121,6 +125,8 @@ class __compressed_pair_padding<_ToPad, true> {};
121	# endif	125	# endif
122		126
123	#else	127	#else
		128	# define _LIBCPP_COMPRESSED_ELEMENT(T1, Initializer1) _LIBCPP_NO_UNIQUE_ADDRESS T1 Initializer1
		129
124	# define _LIBCPP_COMPRESSED_PAIR(T1, Name1, T2, Name2) \	130	# define _LIBCPP_COMPRESSED_PAIR(T1, Name1, T2, Name2) \
125	_LIBCPP_NO_UNIQUE_ADDRESS T1 Name1; \	131	_LIBCPP_NO_UNIQUE_ADDRESS T1 Name1; \
126	_LIBCPP_NO_UNIQUE_ADDRESS T2 Name2	132	_LIBCPP_NO_UNIQUE_ADDRESS T2 Name2

lib/libcxx/include/__memory/construct_at.h+12-23

...	@@ -14,7 +14,6 @@	...	@@ -14,7 +14,6 @@
14	#include <__config>	14	#include <__config>
15	#include <__memory/addressof.h>	15	#include <__memory/addressof.h>
16	#include <__new/placement_new_delete.h>	16	#include <__new/placement_new_delete.h>
17	#include <__type_traits/enable_if.h>
18	#include <__type_traits/is_array.h>	17	#include <__type_traits/is_array.h>
19	#include <__utility/declval.h>	18	#include <__utility/declval.h>
20	#include <__utility/forward.h>	19	#include <__utility/forward.h>
...	@@ -33,7 +32,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -33,7 +32,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
33	#if _LIBCPP_STD_VER >= 20	32	#if _LIBCPP_STD_VER >= 20
34		33
35	template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>	34	template <class _Tp, class... _Args, class = decltype(::new(std::declval<void*>()) _Tp(std::declval<_Args>()...))>
36	_LIBCPP_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* __location, _Args&&... __args) {	35	_LIBCPP_HIDE_FROM_ABI constexpr _Tp* construct_at(_Tp* _LIBCPP_DIAGNOSE_NULLPTR __location, _Args&&... __args) {
37	_LIBCPP_ASSERT_NON_NULL(__location != nullptr, "null pointer given to construct_at");	36	_LIBCPP_ASSERT_NON_NULL(__location != nullptr, "null pointer given to construct_at");
38	return ::new (static_cast<void*>(__location)) _Tp(std::forward<_Args>(__args)...);	37	return ::new (static_cast<void*>(__location)) _Tp(std::forward<_Args>(__args)...);
39	}	38	}
...	@@ -55,35 +54,25 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp* __construct_at(_Tp* __l	...	@@ -55,35 +54,25 @@ _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp* __construct_at(_Tp* __l
55	// The internal functions are available regardless of the language version (with the exception of the `__destroy_at`	54	// The internal functions are available regardless of the language version (with the exception of the `__destroy_at`
56	// taking an array).	55	// taking an array).
57		56
58	template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>	57	template <class _Tp>
59	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy_at(_Tp* __loc) {	58	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __destroy_at(_Tp* __loc) {
60	_LIBCPP_ASSERT_NON_NULL(__loc != nullptr, "null pointer given to destroy_at");	59	_LIBCPP_ASSERT_NON_NULL(__loc != nullptr, "null pointer given to destroy_at");
61	__loc->~_Tp();
62	}
63
64	#if _LIBCPP_STD_VER >= 20	60	#if _LIBCPP_STD_VER >= 20
65	template <class _Tp, __enable_if_t<is_array<_Tp>::value, int> = 0>	61	if constexpr (is_array_v<_Tp>) {
66	_LIBCPP_HIDE_FROM_ABI constexpr void __destroy_at(_Tp* __loc) {	62	for (auto&& __val : *__loc)
67	_LIBCPP_ASSERT_NON_NULL(__loc != nullptr, "null pointer given to destroy_at");	63	std::__destroy_at(std::addressof(__val));
68	for (auto&& __val : *__loc)	64	} else
69	std::__destroy_at(std::addressof(__val));
70	}
71	#endif	65	#endif
72		66	{
73	#if _LIBCPP_STD_VER >= 17	67	__loc->~_Tp();
74		68	}
75	template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
76	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void destroy_at(_Tp* __loc) {
77	std::__destroy_at(__loc);
78	}	69	}
79		70
80	# if _LIBCPP_STD_VER >= 20	71	#if _LIBCPP_STD_VER >= 17
81	template <class _Tp, enable_if_t<is_array_v<_Tp>, int> = 0>	72	template <class _Tp>
82	_LIBCPP_HIDE_FROM_ABI constexpr void destroy_at(_Tp* __loc) {	73	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void destroy_at(_Tp* _LIBCPP_DIAGNOSE_NULLPTR __loc) {
83	std::__destroy_at(__loc);	74	std::__destroy_at(__loc);
84	}	75	}
85	# endif
86
87	#endif // _LIBCPP_STD_VER >= 17	76	#endif // _LIBCPP_STD_VER >= 17
88		77
89	_LIBCPP_END_NAMESPACE_STD	78	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__memory/inout_ptr.h+1-1

...	@@ -96,7 +96,7 @@ private:	...	@@ -96,7 +96,7 @@ private:
96	};	96	};
97		97
98	template <class _Pointer = void, class _Smart, class... _Args>	98	template <class _Pointer = void, class _Smart, class... _Args>
99	_LIBCPP_HIDE_FROM_ABI auto inout_ptr(_Smart& __s, _Args&&... __args) {	99	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI auto inout_ptr(_Smart& __s, _Args&&... __args) {
100	using _Ptr = conditional_t<is_void_v<_Pointer>, __pointer_of_t<_Smart>, _Pointer>;	100	using _Ptr = conditional_t<is_void_v<_Pointer>, __pointer_of_t<_Smart>, _Pointer>;
101	return std::inout_ptr_t<_Smart, _Ptr, _Args&&...>(__s, std::forward<_Args>(__args)...);	101	return std::inout_ptr_t<_Smart, _Ptr, _Args&&...>(__s, std::forward<_Args>(__args)...);
102	}	102	}

lib/libcxx/include/__memory/is_sufficiently_aligned.h+1-1

...	@@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -23,7 +23,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
23	#if _LIBCPP_STD_VER >= 26	23	#if _LIBCPP_STD_VER >= 26
24		24
25	template <size_t _Alignment, class _Tp>	25	template <size_t _Alignment, class _Tp>
26	_LIBCPP_HIDE_FROM_ABI bool is_sufficiently_aligned(_Tp* __ptr) {	26	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_sufficiently_aligned(_Tp* __ptr) {
27	return reinterpret_cast<uintptr_t>(__ptr) % _Alignment == 0;	27	return reinterpret_cast<uintptr_t>(__ptr) % _Alignment == 0;
28	}	28	}
29		29

lib/libcxx/include/__memory/out_ptr.h+1-1

...	@@ -88,7 +88,7 @@ private:	...	@@ -88,7 +88,7 @@ private:
88	};	88	};
89		89
90	template <class _Pointer = void, class _Smart, class... _Args>	90	template <class _Pointer = void, class _Smart, class... _Args>
91	_LIBCPP_HIDE_FROM_ABI auto out_ptr(_Smart& __s, _Args&&... __args) {	91	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI auto out_ptr(_Smart& __s, _Args&&... __args) {
92	using _Ptr = conditional_t<is_void_v<_Pointer>, __pointer_of_t<_Smart>, _Pointer>;	92	using _Ptr = conditional_t<is_void_v<_Pointer>, __pointer_of_t<_Smart>, _Pointer>;
93	return std::out_ptr_t<_Smart, _Ptr, _Args&&...>(__s, std::forward<_Args>(__args)...);	93	return std::out_ptr_t<_Smart, _Ptr, _Args&&...>(__s, std::forward<_Args>(__args)...);
94	}	94	}

lib/libcxx/include/__memory/pointer_traits.h+1-1

...	@@ -255,7 +255,7 @@ concept __resettable_smart_pointer_with_args = requires(_Smart __s, _Pointer __p	...	@@ -255,7 +255,7 @@ concept __resettable_smart_pointer_with_args = requires(_Smart __s, _Pointer __p
255	// This function ensures safe conversions between fancy pointers at compile-time, where we avoid casts from/to	255	// This function ensures safe conversions between fancy pointers at compile-time, where we avoid casts from/to
256	// `__void_pointer` by obtaining the underlying raw pointer from the fancy pointer using `std::to_address`,	256	// `__void_pointer` by obtaining the underlying raw pointer from the fancy pointer using `std::to_address`,
257	// then dereferencing it to retrieve the pointed-to object, and finally constructing the target fancy pointer	257	// then dereferencing it to retrieve the pointed-to object, and finally constructing the target fancy pointer
258	// to that object using the `std::pointer_traits<>::pinter_to` function.	258	// to that object using the `std::pointer_traits<>::pointer_to` function.
259	template <class _PtrTo, class _PtrFrom>	259	template <class _PtrTo, class _PtrFrom>
260	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _PtrTo __static_fancy_pointer_cast(const _PtrFrom& __p) {	260	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI _PtrTo __static_fancy_pointer_cast(const _PtrFrom& __p) {
261	using __ptr_traits = pointer_traits<_PtrTo>;	261	using __ptr_traits = pointer_traits<_PtrTo>;

lib/libcxx/include/__memory/raw_storage_iterator.h+3-9

 @@ -28,15 +28,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_RAW_STORAGE_ITERATOR)
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
 template <class _OutputIterator, class _Tp>
 class _LIBCPP_DEPRECATED_IN_CXX17 raw_storage_iterator
-#  if _LIBCPP_STD_VER <= 14 || !defined(_LIBCPP_ABI_NO_ITERATOR_BASES)
+    : public __iterator_base<raw_storage_iterator<_OutputIterator, _Tp>, output_iterator_tag, void, void, void, void> {
-    : public iterator<output_iterator_tag, void, void, void, void>
-#  endif
-{
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 private:
   _OutputIterator __x_;
 @@ -52,7 +46,7 @@ public:
   typedef void reference;
   _LIBCPP_HIDE_FROM_ABI explicit raw_storage_iterator(_OutputIterator __x) : __x_(__x) {}
-  _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator*() { return *this; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator*() { return *this; }
   _LIBCPP_HIDE_FROM_ABI raw_storage_iterator& operator=(const _Tp& __element) {
     ::new ((void*)std::addressof(*__x_)) _Tp(__element);
     return *this;
 @@ -73,7 +67,7 @@ public:
     return __t;
   }
 #  if _LIBCPP_STD_VER >= 14
-  _LIBCPP_HIDE_FROM_ABI _OutputIterator base() const { return __x_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _OutputIterator base() const { return __x_; }
 #  endif
 };

lib/libcxx/include/__memory/shared_count.h+9-30

 @@ -22,37 +22,10 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
 // should be sufficient for thread safety.
 // See https://llvm.org/PR22803
-#if (defined(__clang__) && __has_builtin(__atomic_add_fetch) && defined(__ATOMIC_RELAXED) &&                           \
-     defined(__ATOMIC_ACQ_REL)) ||                                                                                     \
-    defined(_LIBCPP_COMPILER_GCC)
-#  define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT 1
-#else
-#  define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT 0
-#endif
-template <class _ValueType>
-inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_relaxed_load(_ValueType const* __value) {
-#if _LIBCPP_HAS_THREADS && defined(__ATOMIC_RELAXED) &&                                                                \
-    (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
-  return __atomic_load_n(__value, __ATOMIC_RELAXED);
-#else
-  return *__value;
-#endif
-}
-template <class _ValueType>
-inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_acquire_load(_ValueType const* __value) {
-#if _LIBCPP_HAS_THREADS && defined(__ATOMIC_ACQUIRE) &&                                                                \
-    (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
-  return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
-#else
-  return *__value;
-#endif
-}
 template <class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT {
-#if _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT && _LIBCPP_HAS_THREADS
+#if _LIBCPP_HAS_THREADS
   return __atomic_add_fetch(std::addressof(__t), 1, __ATOMIC_RELAXED);
 #else
   return __t += 1;
 @@ -61,7 +34,7 @@ inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_increment(_Tp& __t) _N
 template <class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT {
-#if _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT && _LIBCPP_HAS_THREADS
+#if _LIBCPP_HAS_THREADS
   return __atomic_add_fetch(std::addressof(__t), -1, __ATOMIC_ACQ_REL);
 #else
   return __t -= 1;
 @@ -95,7 +68,13 @@ public:
     return false;
   }
 #endif
-  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __libcpp_relaxed_load(&__shared_owners_) + 1; }
+  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT {
+#if _LIBCPP_HAS_THREADS
+    return __atomic_load_n(&__shared_owners_, __ATOMIC_RELAXED) + 1;
+#else
+    return __shared_owners_ + 1;
+#endif
+  }
 };
 class _LIBCPP_EXPORTED_FROM_ABI __shared_weak_count : private __shared_count {

lib/libcxx/include/__memory/shared_ptr.h+100-145

 @@ -41,19 +41,18 @@
 #include <__type_traits/enable_if.h>
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_array.h>
-#include <__type_traits/is_bounded_array.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_reference.h>
 #include <__type_traits/is_same.h>
-#include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/nat.h>
 #include <__type_traits/negation.h>
 #include <__type_traits/remove_cv.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/remove_reference.h>
 #include <__utility/declval.h>
+#include <__utility/exception_guard.h>
 #include <__utility/forward.h>
 #include <__utility/move.h>
 #include <__utility/swap.h>
 @@ -78,7 +77,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT            = default;
   _LIBCPP_HIDE_FROM_ABI bad_weak_ptr& operator=(const bad_weak_ptr&) _NOEXCEPT = default;
   ~bad_weak_ptr() _NOEXCEPT override;
-  const char* what() const _NOEXCEPT override;
+  [[__nodiscard__]] const char* what() const _NOEXCEPT override;
 };
 [[__noreturn__]] inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_weak_ptr() {
 @@ -316,10 +315,8 @@ public:
 #endif
   // A shared_ptr contains only two raw pointers which point to the heap and move constructing already doesn't require
-  // any bookkeeping, so it's always trivially relocatable. It is also replaceable because assignment just rebinds the
+  // any bookkeeping, so it's always trivially relocatable.
-  // shared_ptr to manage a different object.
   using __trivially_relocatable _LIBCPP_NODEBUG = shared_ptr;
-  using __replaceable _LIBCPP_NODEBUG           = shared_ptr;
 private:
   element_type* __ptr_;
 @@ -352,23 +349,16 @@ public:
   template <class _Yp, class _Dp, __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI shared_ptr(_Yp* __p, _Dp __d) : __ptr_(__p) {
-#if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] { __d(__p); });
-    try {
+    typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-#endif // _LIBCPP_HAS_EXCEPTIONS
+    typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk;
-      typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-      typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk;
 #ifndef _LIBCPP_CXX03_LANG
-      __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
+    __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
 #else
     __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
 #endif // not _LIBCPP_CXX03_LANG
-      __enable_weak_this(__p, __p);
+    __enable_weak_this(__p, __p);
-#if _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
-    } catch (...) {
-      __d(__p);
-      throw;
-    }
-#endif // _LIBCPP_HAS_EXCEPTIONS
   }
   template <class _Yp,
 @@ -376,28 +366,21 @@ public:
             class _Alloc,
             __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI shared_ptr(_Yp* __p, _Dp __d, _Alloc __a) : __ptr_(__p) {
-#if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] { __d(__p); });
-    try {
+    typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
-#endif // _LIBCPP_HAS_EXCEPTIONS
+    typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
-      typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
+    typedef __allocator_destructor<_A2> _D2;
-      typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
+    _A2 __a2(__a);
-      typedef __allocator_destructor<_A2> _D2;
+    unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-      _A2 __a2(__a);
+    ::new ((void*)std::addressof(*__hold2.get()))
-      unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-      ::new ((void*)std::addressof(*__hold2.get()))
 #ifndef _LIBCPP_CXX03_LANG
-          _CntrlBlk(__p, std::move(__d), __a);
+        _CntrlBlk(__p, std::move(__d), __a);
 #else
         _CntrlBlk(__p, __d, __a);
 #endif // not _LIBCPP_CXX03_LANG
-      __cntrl_ = std::addressof(*__hold2.release());
+    __cntrl_ = std::addressof(*__hold2.release());
-      __enable_weak_this(__p, __p);
+    __enable_weak_this(__p, __p);
-#if _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
-    } catch (...) {
-      __d(__p);
-      throw;
-    }
-#endif // _LIBCPP_HAS_EXCEPTIONS
   }
   template <class _Dp>
 @@ -406,22 +389,15 @@ public:
       _Dp __d,
       __enable_if_t<__shared_ptr_nullptr_deleter_ctor_reqs<_Dp>::value, __nullptr_sfinae_tag> = __nullptr_sfinae_tag())
       : __ptr_(nullptr) {
-#if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] { __d(__p); });
-    try {
+    typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
-#endif // _LIBCPP_HAS_EXCEPTIONS
+    typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk;
-      typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
-      typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk;
 #ifndef _LIBCPP_CXX03_LANG
-      __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
+    __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
 #else
     __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
 #endif // not _LIBCPP_CXX03_LANG
-#if _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
-    } catch (...) {
-      __d(__p);
-      throw;
-    }
-#endif // _LIBCPP_HAS_EXCEPTIONS
   }
   template <class _Dp, class _Alloc>
 @@ -431,27 +407,20 @@ public:
       _Alloc __a,
       __enable_if_t<__shared_ptr_nullptr_deleter_ctor_reqs<_Dp>::value, __nullptr_sfinae_tag> = __nullptr_sfinae_tag())
       : __ptr_(nullptr) {
-#if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] { __d(__p); });
-    try {
+    typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
-#endif // _LIBCPP_HAS_EXCEPTIONS
+    typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
-      typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
+    typedef __allocator_destructor<_A2> _D2;
-      typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
+    _A2 __a2(__a);
-      typedef __allocator_destructor<_A2> _D2;
+    unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-      _A2 __a2(__a);
+    ::new ((void*)std::addressof(*__hold2.get()))
-      unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-      ::new ((void*)std::addressof(*__hold2.get()))
 #ifndef _LIBCPP_CXX03_LANG
-          _CntrlBlk(__p, std::move(__d), __a);
+        _CntrlBlk(__p, std::move(__d), __a);
 #else
         _CntrlBlk(__p, __d, __a);
 #endif // not _LIBCPP_CXX03_LANG
-      __cntrl_ = std::addressof(*__hold2.release());
+    __cntrl_ = std::addressof(*__hold2.release());
-#if _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
-    } catch (...) {
-      __d(__p);
-      throw;
-    }
-#endif // _LIBCPP_HAS_EXCEPTIONS
   }
   template <class _Yp>
 @@ -514,45 +483,16 @@ public:
   template <class _Yp,
             class _Dp,
-            __enable_if_t<!is_lvalue_reference<_Dp>::value && __compatible_with<_Yp, _Tp>::value &&
+            __enable_if_t<__compatible_with<_Yp, _Tp>::value &&
                               is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
                           int> = 0>
   _LIBCPP_HIDE_FROM_ABI shared_ptr(unique_ptr<_Yp, _Dp>&& __r) : __ptr_(__r.get()) {
-#if _LIBCPP_STD_VER >= 14
+    using _AllocT   = typename __shared_ptr_default_allocator<_Yp>::type;
-    if (__ptr_ == nullptr)
+    using _Deleter  = _If<is_lvalue_reference<_Dp>::value, reference_wrapper<__libcpp_remove_reference_t<_Dp> >, _Dp>;
-      __cntrl_ = nullptr;
+    using _CntrlBlk = __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Deleter, _AllocT>;
-    else
-#endif
-    {
-      typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-      typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT> _CntrlBlk;
-      __cntrl_ = new _CntrlBlk(__r.get(), std::move(__r.get_deleter()), _AllocT());
-      __enable_weak_this(__r.get(), __r.get());
-    }
-    __r.release();
-  }
-  template <class _Yp,
+    __cntrl_ = __ptr_ ? new _CntrlBlk(__r.get(), std::forward<_Dp>(__r.get_deleter()), _AllocT()) : nullptr;
-            class _Dp,
+    __enable_weak_this(__r.get(), __r.get());
-            class              = void,
-            __enable_if_t<is_lvalue_reference<_Dp>::value && __compatible_with<_Yp, _Tp>::value &&
-                              is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value,
-                          int> = 0>
-  _LIBCPP_HIDE_FROM_ABI shared_ptr(unique_ptr<_Yp, _Dp>&& __r) : __ptr_(__r.get()) {
-#if _LIBCPP_STD_VER >= 14
-    if (__ptr_ == nullptr)
-      __cntrl_ = nullptr;
-    else
-#endif
-    {
-      typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
-      typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
-                                   reference_wrapper<__libcpp_remove_reference_t<_Dp> >,
-                                   _AllocT>
-          _CntrlBlk;
-      __cntrl_ = new _CntrlBlk(__r.get(), std::ref(__r.get_deleter()), _AllocT());
-      __enable_weak_this(__r.get(), __r.get());
-    }
     __r.release();
   }
 @@ -628,37 +568,43 @@ public:
     shared_ptr(__p, __d, __a).swap(*this);
   }
-  _LIBCPP_HIDE_FROM_ABI element_type* get() const _NOEXCEPT { return __ptr_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI element_type* get() const _NOEXCEPT { return __ptr_; }
-  _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator*() const _NOEXCEPT { return *__ptr_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator*() const _NOEXCEPT {
+    return *__ptr_;
+  }
   _LIBCPP_HIDE_FROM_ABI element_type* operator->() const _NOEXCEPT {
     static_assert(!is_array<_Tp>::value, "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
     return __ptr_;
   }
-  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __cntrl_ ? __cntrl_->use_count() : 0; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT {
+    return __cntrl_ ? __cntrl_->use_count() : 0;
+  }
 #if _LIBCPP_STD_VER < 20 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_SHARED_PTR_UNIQUE)
-  _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI bool unique() const _NOEXCEPT { return use_count() == 1; }
+  [[__nodiscard__]] _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI bool unique() const _NOEXCEPT {
+    return use_count() == 1;
+  }
 #endif
   _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return get() != nullptr; }
   template <class _Up>
-  _LIBCPP_HIDE_FROM_ABI bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT {
     return __cntrl_ < __p.__cntrl_;
   }
   template <class _Up>
-  _LIBCPP_HIDE_FROM_ABI bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT {
     return __cntrl_ < __p.__cntrl_;
   }
   _LIBCPP_HIDE_FROM_ABI bool __owner_equivalent(const shared_ptr& __p) const { return __cntrl_ == __p.__cntrl_; }
 #if _LIBCPP_STD_VER >= 17
-  _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const {
     static_assert(is_array<_Tp>::value, "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
     return __ptr_[__i];
   }
 @@ -729,7 +675,7 @@ shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
 // std::allocate_shared and std::make_shared
 //
 template <class _Tp, class _Alloc, class... _Args, __enable_if_t<!is_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&... __args) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&... __args) {
   using _ControlBlock          = __shared_ptr_emplace<_Tp, _Alloc>;
   using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type;
   __allocation_guard<_ControlBlockAllocator> __guard(__a, 1);
 @@ -740,21 +686,21 @@ _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&
 }
 template <class _Tp, class... _Args, __enable_if_t<!is_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(_Args&&... __args) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(_Args&&... __args) {
   return std::allocate_shared<_Tp>(allocator<__remove_cv_t<_Tp> >(), std::forward<_Args>(__args)...);
 }
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Alloc, __enable_if_t<!is_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
   using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
   _ForOverwriteAllocator __alloc(__a);
   return std::allocate_shared<_Tp>(__alloc);
 }
 template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
   return std::allocate_shared_for_overwrite<_Tp>(allocator<__remove_cv_t<_Tp>>());
 }
 @@ -946,67 +892,69 @@ _LIBCPP_HIDE_FROM_ABI shared_ptr<_Array> __allocate_shared_bounded_array(const _
 // bounded array variants
 template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a) {
   return std::__allocate_shared_bounded_array<_Tp>(__a);
 }
 template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
+allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u) {
   return std::__allocate_shared_bounded_array<_Tp>(__a, __u);
 }
 template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
   using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
   _ForOverwriteAllocator __alloc(__a);
   return std::__allocate_shared_bounded_array<_Tp>(__alloc);
 }
 template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared() {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared() {
   return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>());
 }
 template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u) {
   return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>(), __u);
 }
 template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
   return std::__allocate_shared_bounded_array<_Tp>(allocator<__for_overwrite_tag>());
 }
 // unbounded array variants
 template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n) {
   return std::__allocate_shared_unbounded_array<_Tp>(__a, __n);
 }
 template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
+allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u) {
   return std::__allocate_shared_unbounded_array<_Tp>(__a, __n, __u);
 }
 template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a, size_t __n) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a, size_t __n) {
   using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
   _ForOverwriteAllocator __alloc(__a);
   return std::__allocate_shared_unbounded_array<_Tp>(__alloc, __n);
 }
 template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n) {
   return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n);
 }
 template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u) {
   return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n, __u);
 }
 template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite(size_t __n) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite(size_t __n) {
   return std::__allocate_shared_unbounded_array<_Tp>(allocator<__for_overwrite_tag>(), __n);
 }
 @@ -1135,7 +1083,8 @@ inline _LIBCPP_HIDE_FROM_ABI void swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __
 }
 template <class _Tp, class _Up>
-inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
+static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
   return shared_ptr<_Tp>(__r, static_cast< typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
 @@ -1143,13 +1092,14 @@ inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(const shared_pt
 // We don't backport because it is an evolutionary change.
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
   return shared_ptr<_Tp>(std::move(__r), static_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
 #endif
 template <class _Tp, class _Up>
-inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+[[__nodiscard__]] inline
+    _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
   typedef typename shared_ptr<_Tp>::element_type _ET;
   _ET* __p = dynamic_cast<_ET*>(__r.get());
   return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
 @@ -1159,14 +1109,14 @@ inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(const shared_p
 // We don't backport because it is an evolutionary change.
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
   auto* __p = dynamic_cast<typename shared_ptr<_Tp>::element_type*>(__r.get());
   return __p ? shared_ptr<_Tp>(std::move(__r), __p) : shared_ptr<_Tp>();
 }
 #endif
 template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
   typedef typename shared_ptr<_Tp>::element_type _RTp;
   return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
 }
 @@ -1175,13 +1125,13 @@ _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>&
 // We don't backport because it is an evolutionary change.
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
   return shared_ptr<_Tp>(std::move(__r), const_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
 #endif
 template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
   return shared_ptr<_Tp>(__r, reinterpret_cast< typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
 @@ -1189,7 +1139,7 @@ _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<
 // We don't backport because it is an evolutionary change.
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, class _Up>
-_LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
   return shared_ptr<_Tp>(std::move(__r), reinterpret_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
 }
 #endif
 @@ -1197,7 +1147,7 @@ _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&&
 #if _LIBCPP_HAS_RTTI
 template <class _Dp, class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _Dp* get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Dp* get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT {
   return __p.template __get_deleter<_Dp>();
 }
 @@ -1213,9 +1163,8 @@ public:
 #endif
   // A weak_ptr contains only two raw pointers which point to the heap and move constructing already doesn't require
-  // any bookkeeping, so it's always trivially relocatable. It's also replaceable for the same reason.
+  // any bookkeeping, so it's always trivially relocatable.
   using __trivially_relocatable _LIBCPP_NODEBUG = weak_ptr;
-  using __replaceable _LIBCPP_NODEBUG           = weak_ptr;
 private:
   element_type* __ptr_;
 @@ -1253,15 +1202,19 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(weak_ptr& __r) _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __cntrl_ ? __cntrl_->use_count() : 0; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI bool expired() const _NOEXCEPT { return __cntrl_ == nullptr || __cntrl_->use_count() == 0; }
+    return __cntrl_ ? __cntrl_->use_count() : 0;
-  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> lock() const _NOEXCEPT;
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool expired() const _NOEXCEPT {
+    return __cntrl_ == nullptr || __cntrl_->use_count() == 0;
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> lock() const _NOEXCEPT;
   template <class _Up>
-  _LIBCPP_HIDE_FROM_ABI bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT {
     return __cntrl_ < __r.__cntrl_;
   }
   template <class _Up>
-  _LIBCPP_HIDE_FROM_ABI bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT {
     return __cntrl_ < __r.__cntrl_;
   }
 @@ -1445,13 +1398,15 @@ protected:
   _LIBCPP_HIDE_FROM_ABI ~enable_shared_from_this() {}
 public:
-  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(__weak_this_); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(__weak_this_); }
-  _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp const> shared_from_this() const { return shared_ptr<const _Tp>(__weak_this_); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp const> shared_from_this() const {
+    return shared_ptr<const _Tp>(__weak_this_);
+  }
 #if _LIBCPP_STD_VER >= 17
-  _LIBCPP_HIDE_FROM_ABI weak_ptr<_Tp> weak_from_this() _NOEXCEPT { return __weak_this_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI weak_ptr<_Tp> weak_from_this() _NOEXCEPT { return __weak_this_; }
-  _LIBCPP_HIDE_FROM_ABI weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT { return __weak_this_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT { return __weak_this_; }
 #endif // _LIBCPP_STD_VER >= 17
   template <class _Up>
 @@ -1468,7 +1423,7 @@ struct hash<shared_ptr<_Tp> > {
   _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
 #endif
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT {
     return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
   }
 };

lib/libcxx/include/__memory/temp_value.h+1-2

...	@@ -12,7 +12,6 @@	...	@@ -12,7 +12,6 @@
12	#include <__config>	12	#include <__config>
13	#include <__memory/addressof.h>	13	#include <__memory/addressof.h>
14	#include <__memory/allocator_traits.h>	14	#include <__memory/allocator_traits.h>
15	#include <__type_traits/aligned_storage.h>
16	#include <__utility/forward.h>	15	#include <__utility/forward.h>
17		16
18	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -26,7 +25,7 @@ struct __temp_value {	...	@@ -26,7 +25,7 @@ struct __temp_value {
26	typedef allocator_traits<_Alloc> _Traits;	25	typedef allocator_traits<_Alloc> _Traits;
27		26
28	#ifdef _LIBCPP_CXX03_LANG	27	#ifdef _LIBCPP_CXX03_LANG
29	typename aligned_storage<sizeof(_Tp), _LIBCPP_ALIGNOF(_Tp)>::type __v;	28	_ALIGNAS_TYPE(_Tp) char __v[sizeof(_Tp)];
30	#else	29	#else
31	union {	30	union {
32	_Tp __v;	31	_Tp __v;

lib/libcxx/include/__memory/uninitialized_algorithms.h+44-115

 @@ -32,7 +32,6 @@
 #include <__type_traits/is_trivially_assignable.h>
 #include <__type_traits/is_trivially_constructible.h>
 #include <__type_traits/is_trivially_relocatable.h>
-#include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/remove_const.h>
 #include <__type_traits/remove_extent.h>
 #include <__utility/exception_guard.h>
 @@ -61,17 +60,10 @@ template <class _ValueType, class _InputIterator, class _Sentinel1, class _Forwa
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_copy(
     _InputIterator __ifirst, _Sentinel1 __ilast, _ForwardIterator __ofirst, _EndPredicate __stop_copying) {
   _ForwardIterator __idx = __ofirst;
-#if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard           = std::__make_exception_guard([&] { std::__destroy(__ofirst, __idx); });
-  try {
+  for (; __ifirst != __ilast && !__stop_copying(__idx); ++__ifirst, (void)++__idx)
-#endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(*__ifirst);
-    for (; __ifirst != __ilast && !__stop_copying(__idx); ++__ifirst, (void)++__idx)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(*__ifirst);
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__ofirst, __idx);
-    throw;
-  }
-#endif
   return pair<_InputIterator, _ForwardIterator>(std::move(__ifirst), std::move(__idx));
 }
 @@ -91,17 +83,10 @@ template <class _ValueType, class _InputIterator, class _Size, class _ForwardIte
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator>
 __uninitialized_copy_n(_InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst, _EndPredicate __stop_copying) {
   _ForwardIterator __idx = __ofirst;
-#if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard           = std::__make_exception_guard([&] { std::__destroy(__ofirst, __idx); });
-  try {
+  for (; __n > 0 && !__stop_copying(__idx); ++__ifirst, (void)++__idx, (void)--__n)
-#endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(*__ifirst);
-    for (; __n > 0 && !__stop_copying(__idx); ++__ifirst, (void)++__idx, (void)--__n)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(*__ifirst);
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__ofirst, __idx);
-    throw;
-  }
-#endif
   return pair<_InputIterator, _ForwardIterator>(std::move(__ifirst), std::move(__idx));
 }
 @@ -121,17 +106,10 @@ template <class _ValueType, class _ForwardIterator, class _Sentinel, class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
 __uninitialized_fill(_ForwardIterator __first, _Sentinel __last, const _Tp& __x) {
   _ForwardIterator __idx = __first;
-#if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard           = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
-  try {
+  for (; __idx != __last; ++__idx)
-#endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__x);
-    for (; __idx != __last; ++__idx)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__x);
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__first, __idx);
-    throw;
-  }
-#endif
   return __idx;
 }
 @@ -149,17 +127,10 @@ template <class _ValueType, class _ForwardIterator, class _Size, class _Tp>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
 __uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
   _ForwardIterator __idx = __first;
-#if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard           = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
-  try {
+  for (; __n > 0; ++__idx, (void)--__n)
-#endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__x);
-    for (; __n > 0; ++__idx, (void)--__n)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__x);
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__first, __idx);
-    throw;
-  }
-#endif
   return __idx;
 }
 @@ -178,18 +149,11 @@ uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) {
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
 __uninitialized_default_construct(_ForwardIterator __first, _Sentinel __last) {
-  auto __idx = __first;
+  auto __idx   = __first;
-#  if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
-  try {
+  for (; __idx != __last; ++__idx)
-#  endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType;
-    for (; __idx != __last; ++__idx)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType;
-#  if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__first, __idx);
-    throw;
-  }
-#  endif
   return __idx;
 }
 @@ -205,17 +169,10 @@ inline _LIBCPP_HIDE_FROM_ABI void uninitialized_default_construct(_ForwardIterat
 template <class _ValueType, class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator __uninitialized_default_construct_n(_ForwardIterator __first, _Size __n) {
   auto __idx = __first;
-#  if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
-  try {
+  for (; __n > 0; ++__idx, (void)--__n)
-#  endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType;
-    for (; __n > 0; ++__idx, (void)--__n)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType;
-#  if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__first, __idx);
-    throw;
-  }
-#  endif
   return __idx;
 }
 @@ -231,18 +188,11 @@ inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator uninitialized_default_construct_n(
 template <class _ValueType, class _ForwardIterator, class _Sentinel>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator
 __uninitialized_value_construct(_ForwardIterator __first, _Sentinel __last) {
-  auto __idx = __first;
+  auto __idx   = __first;
-#  if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
-  try {
+  for (; __idx != __last; ++__idx)
-#  endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType();
-    for (; __idx != __last; ++__idx)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType();
-#  if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__first, __idx);
-    throw;
-  }
-#  endif
   return __idx;
 }
 @@ -258,17 +208,10 @@ inline _LIBCPP_HIDE_FROM_ABI void uninitialized_value_construct(_ForwardIterator
 template <class _ValueType, class _ForwardIterator, class _Size>
 inline _LIBCPP_HIDE_FROM_ABI _ForwardIterator __uninitialized_value_construct_n(_ForwardIterator __first, _Size __n) {
   auto __idx = __first;
-#  if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__first, __idx); });
-  try {
+  for (; __n > 0; ++__idx, (void)--__n)
-#  endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType();
-    for (; __n > 0; ++__idx, (void)--__n)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType();
-#  if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__first, __idx);
-    throw;
-  }
-#  endif
   return __idx;
 }
 @@ -293,19 +236,12 @@ inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitiali
     _ForwardIterator __ofirst,
     _EndPredicate __stop_moving,
     _IterMove __iter_move) {
-  auto __idx = __ofirst;
+  auto __idx   = __ofirst;
-#  if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__ofirst, __idx); });
-  try {
+  for (; __ifirst != __ilast && !__stop_moving(__idx); ++__idx, (void)++__ifirst) {
-#  endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__iter_move(__ifirst));
-    for (; __ifirst != __ilast && !__stop_moving(__idx); ++__idx, (void)++__ifirst) {
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__iter_move(__ifirst));
-    }
-#  if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__ofirst, __idx);
-    throw;
   }
-#  endif
+  __guard.__complete();
   return {std::move(__ifirst), std::move(__idx)};
 }
 @@ -331,18 +267,11 @@ template <class _ValueType,
           class _IterMove>
 inline _LIBCPP_HIDE_FROM_ABI pair<_InputIterator, _ForwardIterator> __uninitialized_move_n(
     _InputIterator __ifirst, _Size __n, _ForwardIterator __ofirst, _EndPredicate __stop_moving, _IterMove __iter_move) {
-  auto __idx = __ofirst;
+  auto __idx   = __ofirst;
-#  if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { std::__destroy(__ofirst, __idx); });
-  try {
+  for (; __n > 0 && !__stop_moving(__idx); ++__idx, (void)++__ifirst, --__n)
-#  endif
+    ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__iter_move(__ifirst));
-    for (; __n > 0 && !__stop_moving(__idx); ++__idx, (void)++__ifirst, --__n)
+  __guard.__complete();
-      ::new (static_cast<void*>(std::addressof(*__idx))) _ValueType(__iter_move(__ifirst));
-#  if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    std::__destroy(__ofirst, __idx);
-    throw;
-  }
-#  endif
   return {std::move(__ifirst), std::move(__idx)};
 }

lib/libcxx/include/__memory/unique_ptr.h+14-16

 @@ -32,18 +32,15 @@
 #include <__type_traits/integral_constant.h>
 #include <__type_traits/is_array.h>
 #include <__type_traits/is_assignable.h>
-#include <__type_traits/is_bounded_array.h>
 #include <__type_traits/is_constant_evaluated.h>
 #include <__type_traits/is_constructible.h>
 #include <__type_traits/is_convertible.h>
 #include <__type_traits/is_function.h>
 #include <__type_traits/is_pointer.h>
 #include <__type_traits/is_reference.h>
-#include <__type_traits/is_replaceable.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivially_relocatable.h>
-#include <__type_traits/is_unbounded_array.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/remove_extent.h>
 #include <__type_traits/type_identity.h>
 @@ -145,8 +142,6 @@ public:
       __libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<deleter_type>::value,
       unique_ptr,
       void>;
-  using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable_v<pointer> && __is_replaceable_v<deleter_type>, unique_ptr, void>;
 private:
   _LIBCPP_COMPRESSED_PAIR(pointer, __ptr_, deleter_type, __deleter_);
 @@ -263,14 +258,17 @@ public:
     return *this;
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp> operator*() const
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 __add_lvalue_reference_t<_Tp> operator*() const
       _NOEXCEPT_(_NOEXCEPT_(*std::declval<pointer>())) {
     return *__ptr_;
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer operator->() const _NOEXCEPT { return __ptr_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 pointer get() const _NOEXCEPT { return __ptr_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT { return __deleter_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 deleter_type& get_deleter() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type& get_deleter() const _NOEXCEPT {
+    return __deleter_;
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 const deleter_type&
+  get_deleter() const _NOEXCEPT {
     return __deleter_;
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 explicit operator bool() const _NOEXCEPT {
 @@ -413,8 +411,6 @@ public:
       __libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<deleter_type>::value,
       unique_ptr,
       void>;
-  using __replaceable _LIBCPP_NODEBUG =
-      __conditional_t<__is_replaceable_v<pointer> && __is_replaceable_v<deleter_type>, unique_ptr, void>;
 private:
   template <class _Up, class _OtherDeleter>
 @@ -755,12 +751,13 @@ operator<=>(const unique_ptr<_T1, _D1>& __x, nullptr_t) {
 #if _LIBCPP_STD_VER >= 14
 template <class _Tp, class... _Args, enable_if_t<!is_array<_Tp>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique(_Args&&... __args) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique(_Args&&... __args) {
   return unique_ptr<_Tp>(new _Tp(std::forward<_Args>(__args)...));
 }
 template <class _Tp, enable_if_t<__is_unbounded_array_v<_Tp>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique(size_t __n) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique(size_t __n) {
   typedef __remove_extent_t<_Tp> _Up;
   return unique_ptr<_Tp>(__private_constructor_tag(), new _Up[__n](), __n);
 }
 @@ -773,12 +770,13 @@ void make_unique(_Args&&...) = delete;
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp, enable_if_t<!is_array_v<_Tp>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique_for_overwrite() {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique_for_overwrite() {
   return unique_ptr<_Tp>(new _Tp);
 }
 template <class _Tp, enable_if_t<is_unbounded_array_v<_Tp>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp> make_unique_for_overwrite(size_t __n) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unique_ptr<_Tp>
+make_unique_for_overwrite(size_t __n) {
   return unique_ptr<_Tp>(__private_constructor_tag(), new __remove_extent_t<_Tp>[__n], __n);
 }
 @@ -802,7 +800,7 @@ struct hash<__enable_hash_helper< unique_ptr<_Tp, _Dp>, typename unique_ptr<_Tp,
   _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
 #endif
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const unique_ptr<_Tp, _Dp>& __ptr) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const unique_ptr<_Tp, _Dp>& __ptr) const {
     typedef typename unique_ptr<_Tp, _Dp>::pointer pointer;
     return hash<pointer>()(__ptr.get());
   }

lib/libcxx/include/__memory/uses_allocator_construction.h+1

...	@@ -17,6 +17,7 @@	...	@@ -17,6 +17,7 @@
17	#include <__type_traits/remove_cv.h>	17	#include <__type_traits/remove_cv.h>
18	#include <__utility/declval.h>	18	#include <__utility/declval.h>
19	#include <__utility/pair.h>	19	#include <__utility/pair.h>
		20	#include <__utility/piecewise_construct.h>
20	#include <tuple>	21	#include <tuple>
21		22
22	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	23	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

lib/libcxx/include/__memory_resource/memory_resource.h+4-2

...	@@ -42,7 +42,9 @@ public:	...	@@ -42,7 +42,9 @@ public:
42	do_deallocate(__p, __bytes, __align);	42	do_deallocate(__p, __bytes, __align);
43	}	43	}
44		44
45	_LIBCPP_HIDE_FROM_ABI bool is_equal(const memory_resource& __other) const noexcept { return do_is_equal(__other); }	45	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_equal(const memory_resource& __other) const noexcept {
		46	return do_is_equal(__other);
		47	}
46		48
47	private:	49	private:
48	virtual void* do_allocate(size_t, size_t) = 0;	50	virtual void* do_allocate(size_t, size_t) = 0;
...	@@ -68,7 +70,7 @@ operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept	...	@@ -68,7 +70,7 @@ operator!=(const memory_resource& __lhs, const memory_resource& __rhs) noexcept
68		70
69	// [mem.res.global]	71	// [mem.res.global]
70		72
71	[[__gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*	73	[[nodiscard, __gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*
72	get_default_resource() noexcept;	74	get_default_resource() noexcept;
73		75
74	[[__gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*	76	[[__gnu__::__returns_nonnull__]] _LIBCPP_AVAILABILITY_PMR _LIBCPP_EXPORTED_FROM_ABI memory_resource*

lib/libcxx/include/__memory_resource/monotonic_buffer_resource.h+1-1

...	@@ -93,7 +93,7 @@ public:	...	@@ -93,7 +93,7 @@ public:
93	}	93	}
94	}	94	}
95		95
96	_LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __res_; }	96	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __res_; }
97		97
98	protected:	98	protected:
99	void* do_allocate(size_t __bytes, size_t __alignment) override; // key function	99	void* do_allocate(size_t __bytes, size_t __alignment) override; // key function

lib/libcxx/include/__memory_resource/polymorphic_allocator.h+13-8

 @@ -18,6 +18,7 @@
 #include <__new/exceptions.h>
 #include <__new/placement_new_delete.h>
 #include <__utility/exception_guard.h>
+#include <__utility/piecewise_construct.h>
 #include <limits>
 #include <tuple>
 @@ -50,7 +51,9 @@ public:
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator() noexcept : __res_(std::pmr::get_default_resource()) {}
-  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(memory_resource* __r) noexcept : __res_(__r) {}
+  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(memory_resource* _LIBCPP_DIAGNOSE_NULLPTR __r) noexcept : __res_(__r) {
+    _LIBCPP_ASSERT_NON_NULL(__r, "Attempted to pass a nullptr resource to polymorphic_alloator");
+  }
   _LIBCPP_HIDE_FROM_ABI polymorphic_allocator(const polymorphic_allocator&) = default;
 @@ -133,10 +136,10 @@ public:
         piecewise_construct,
         __transform_tuple(typename __uses_alloc_ctor< _T1, polymorphic_allocator&, _Args1... >::type(),
                           std::move(__x),
-                          typename __make_tuple_indices<sizeof...(_Args1)>::type{}),
+                          make_index_sequence<sizeof...(_Args1)>()),
         __transform_tuple(typename __uses_alloc_ctor< _T2, polymorphic_allocator&, _Args2... >::type(),
                           std::move(__y),
-                          typename __make_tuple_indices<sizeof...(_Args2)>::type{}));
+                          make_index_sequence<sizeof...(_Args2)>()));
   }
   template <class _T1, class _T2>
 @@ -170,11 +173,13 @@ public:
     __p->~_Tp();
   }
-  _LIBCPP_HIDE_FROM_ABI polymorphic_allocator select_on_container_copy_construction() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI polymorphic_allocator select_on_container_copy_construction() const noexcept {
     return polymorphic_allocator();
   }
-  _LIBCPP_HIDE_FROM_ABI memory_resource* resource() const noexcept { return __res_; }
+  [[nodiscard, __gnu__::__returns_nonnull__]] _LIBCPP_HIDE_FROM_ABI memory_resource* resource() const noexcept {
+    return __res_;
+  }
   _LIBCPP_HIDE_FROM_ABI friend bool
   operator==(const polymorphic_allocator& __lhs, const polymorphic_allocator& __rhs) noexcept {
 @@ -192,20 +197,20 @@ public:
 private:
   template <class... _Args, size_t... _Is>
   _LIBCPP_HIDE_FROM_ABI tuple<_Args&&...>
-  __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, __tuple_indices<_Is...>) {
+  __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, index_sequence<_Is...>) {
     return std::forward_as_tuple(std::get<_Is>(std::move(__t))...);
   }
   template <class... _Args, size_t... _Is>
   _LIBCPP_HIDE_FROM_ABI tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>
-  __transform_tuple(integral_constant<int, 1>, tuple<_Args...>&& __t, __tuple_indices<_Is...>) {
+  __transform_tuple(integral_constant<int, 1>, tuple<_Args...>&& __t, index_sequence<_Is...>) {
     using _Tup = tuple<allocator_arg_t const&, polymorphic_allocator&, _Args&&...>;
     return _Tup(allocator_arg, *this, std::get<_Is>(std::move(__t))...);
   }
   template <class... _Args, size_t... _Is>
   _LIBCPP_HIDE_FROM_ABI tuple<_Args&&..., polymorphic_allocator&>
-  __transform_tuple(integral_constant<int, 2>, tuple<_Args...>&& __t, __tuple_indices<_Is...>) {
+  __transform_tuple(integral_constant<int, 2>, tuple<_Args...>&& __t, index_sequence<_Is...>) {
     using _Tup = tuple<_Args&&..., polymorphic_allocator&>;
     return _Tup(std::get<_Is>(std::move(__t))..., *this);
   }

lib/libcxx/include/__memory_resource/pool_options.h+1-1

...	@@ -24,7 +24,7 @@ namespace pmr {	...	@@ -24,7 +24,7 @@ namespace pmr {
24		24
25	// [mem.res.pool.options]	25	// [mem.res.pool.options]
26		26
27	struct _LIBCPP_EXPORTED_FROM_ABI pool_options {	27	struct pool_options {
28	size_t max_blocks_per_chunk = 0;	28	size_t max_blocks_per_chunk = 0;
29	size_t largest_required_pool_block = 0;	29	size_t largest_required_pool_block = 0;
30	};	30	};

lib/libcxx/include/__memory_resource/synchronized_pool_resource.h+4-2

 @@ -56,9 +56,11 @@ public:
     __unsync_.release();
   }
-  _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __unsync_.upstream_resource(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const {
+    return __unsync_.upstream_resource();
+  }
-  _LIBCPP_HIDE_FROM_ABI pool_options options() const { return __unsync_.options(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI pool_options options() const { return __unsync_.options(); }
 protected:
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL void* do_allocate(size_t __bytes, size_t __align) override {

lib/libcxx/include/__memory_resource/unsynchronized_pool_resource.h+1-1

...	@@ -76,7 +76,7 @@ public:	...	@@ -76,7 +76,7 @@ public:
76		76
77	void release();	77	void release();
78		78
79	_LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __res_; }	79	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI memory_resource* upstream_resource() const { return __res_; }
80		80
81	[[__gnu__::__pure__]] pool_options options() const;	81	[[__gnu__::__pure__]] pool_options options() const;
82		82

lib/libcxx/include/__mutex/mutex.h+2-2

...	@@ -37,11 +37,11 @@ public:	...	@@ -37,11 +37,11 @@ public:
37	# endif	37	# endif
38		38
39	_LIBCPP_ACQUIRE_CAPABILITY() void lock();	39	_LIBCPP_ACQUIRE_CAPABILITY() void lock();
40	_LIBCPP_TRY_ACQUIRE_CAPABILITY(true) bool try_lock() _NOEXCEPT;	40	[[__nodiscard__]] _LIBCPP_TRY_ACQUIRE_CAPABILITY(true) bool try_lock() _NOEXCEPT;
41	_LIBCPP_RELEASE_CAPABILITY void unlock() _NOEXCEPT;	41	_LIBCPP_RELEASE_CAPABILITY void unlock() _NOEXCEPT;
42		42
43	typedef __libcpp_mutex_t* native_handle_type;	43	typedef __libcpp_mutex_t* native_handle_type;
44	_LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }	44	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
45	};	45	};
46		46
47	static_assert(is_nothrow_default_constructible<mutex>::value, "the default constructor for std::mutex must be nothrow");	47	static_assert(is_nothrow_default_constructible<mutex>::value, "the default constructor for std::mutex must be nothrow");

lib/libcxx/include/__mutex/once_flag.h+14-11

 @@ -10,12 +10,11 @@
 #define _LIBCPP___MUTEX_ONCE_FLAG_H
 #include <__config>
-#include <__functional/invoke.h>
 #include <__memory/addressof.h>
-#include <__memory/shared_count.h> // __libcpp_acquire_load
-#include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_size.h>
+#include <__type_traits/invoke.h>
 #include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <cstdint>
 #ifndef _LIBCPP_CXX03_LANG
 @@ -88,14 +87,9 @@ public:
   _LIBCPP_HIDE_FROM_ABI explicit __call_once_param(_Fp& __f) : __f_(__f) {}
   _LIBCPP_HIDE_FROM_ABI void operator()() {
-    typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 1>::type _Index;
+    [&]<size_t... _Indices>(__index_sequence<_Indices...>) -> void {
-    __execute(_Index());
+      std::__invoke(std::get<_Indices>(std::move(__f_))...);
-  }
+    }(__make_index_sequence<tuple_size<_Fp>::value>());
-private:
-  template <size_t... _Indices>
-  _LIBCPP_HIDE_FROM_ABI void __execute(__tuple_indices<_Indices...>) {
-    std::__invoke(std::get<0>(std::move(__f_)), std::get<_Indices>(std::move(__f_))...);
   }
 };
 @@ -121,6 +115,15 @@ void _LIBCPP_HIDE_FROM_ABI __call_once_proxy(void* __vp) {
 _LIBCPP_EXPORTED_FROM_ABI void __call_once(volatile once_flag::_State_type&, void*, void (*)(void*));
+template <class _ValueType>
+inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_acquire_load(_ValueType const* __value) {
+#if _LIBCPP_HAS_THREADS
+  return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
+#else
+  return *__value;
+#endif
+}
 #ifndef _LIBCPP_CXX03_LANG
 template <class _Callable, class... _Args>

lib/libcxx/include/__mutex/tag_types.h+3-3

...	@@ -17,15 +17,15 @@	...	@@ -17,15 +17,15 @@
17		17
18	_LIBCPP_BEGIN_NAMESPACE_STD	18	_LIBCPP_BEGIN_NAMESPACE_STD
19		19
20	struct _LIBCPP_EXPORTED_FROM_ABI defer_lock_t {	20	struct defer_lock_t {
21	explicit defer_lock_t() = default;	21	explicit defer_lock_t() = default;
22	};	22	};
23		23
24	struct _LIBCPP_EXPORTED_FROM_ABI try_to_lock_t {	24	struct try_to_lock_t {
25	explicit try_to_lock_t() = default;	25	explicit try_to_lock_t() = default;
26	};	26	};
27		27
28	struct _LIBCPP_EXPORTED_FROM_ABI adopt_lock_t {	28	struct adopt_lock_t {
29	explicit adopt_lock_t() = default;	29	explicit adopt_lock_t() = default;
30	};	30	};
31		31

lib/libcxx/include/__mutex/unique_lock.h+8-7

...	@@ -15,6 +15,7 @@	...	@@ -15,6 +15,7 @@
15	#include <__memory/addressof.h>	15	#include <__memory/addressof.h>
16	#include <__mutex/tag_types.h>	16	#include <__mutex/tag_types.h>
17	#include <__system_error/throw_system_error.h>	17	#include <__system_error/throw_system_error.h>
		18	#include <__utility/move.h>
18	#include <__utility/swap.h>	19	#include <__utility/swap.h>
19	#include <cerrno>	20	#include <cerrno>
20		21
...	@@ -22,6 +23,9 @@	...	@@ -22,6 +23,9 @@
22	# pragma GCC system_header	23	# pragma GCC system_header
23	#endif	24	#endif
24		25
		26	_LIBCPP_PUSH_MACROS
		27	#include <__undef_macros>
		28
25	_LIBCPP_BEGIN_NAMESPACE_STD	29	_LIBCPP_BEGIN_NAMESPACE_STD
26		30
27	template <class _Mutex>	31	template <class _Mutex>
...	@@ -74,13 +78,8 @@ public:	...	@@ -74,13 +78,8 @@ public:
74	}	78	}
75		79
76	_LIBCPP_HIDE_FROM_ABI unique_lock& operator=(unique_lock&& __u) _NOEXCEPT {	80	_LIBCPP_HIDE_FROM_ABI unique_lock& operator=(unique_lock&& __u) _NOEXCEPT {
77	if (__owns_)	81	if (this != std::addressof(__u))
78	__m_->unlock();	82	unique_lock(std::move(__u)).swap(*this);
79
80	__m_ = __u.__m_;
81	__owns_ = __u.__owns_;
82	__u.__m_ = nullptr;
83	__u.__owns_ = false;
84	return *this;	83	return *this;
85	}	84	}
86		85
...	@@ -170,4 +169,6 @@ inline _LIBCPP_HIDE_FROM_ABI void swap(unique_lock<_Mutex>& __x, unique_lock<_Mu	...	@@ -170,4 +169,6 @@ inline _LIBCPP_HIDE_FROM_ABI void swap(unique_lock<_Mutex>& __x, unique_lock<_Mu
170		169
171	_LIBCPP_END_NAMESPACE_STD	170	_LIBCPP_END_NAMESPACE_STD
172		171
		172	_LIBCPP_POP_MACROS
		173
173	#endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H	174	#endif // _LIBCPP___MUTEX_UNIQUE_LOCK_H

lib/libcxx/include/__new/align_val_t.h+6

...	@@ -16,6 +16,12 @@	...	@@ -16,6 +16,12 @@
16	# pragma GCC system_header	16	# pragma GCC system_header
17	#endif	17	#endif
18		18
		19	// <vcruntime_exception.h> defines its own std::align_val_t type,
		20	// which we use in order to be ABI-compatible with other STLs on Windows.
		21	#if _LIBCPP_HAS_LIBRARY_ALIGNED_ALLOCATION && defined(_LIBCPP_ABI_VCRUNTIME)
		22	# include <vcruntime_new.h>
		23	#endif
		24
19	_LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD	25	_LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD
20	#if _LIBCPP_HAS_LIBRARY_ALIGNED_ALLOCATION && !defined(_LIBCPP_ABI_VCRUNTIME)	26	#if _LIBCPP_HAS_LIBRARY_ALIGNED_ALLOCATION && !defined(_LIBCPP_ABI_VCRUNTIME)
21	# ifndef _LIBCPP_CXX03_LANG	27	# ifndef _LIBCPP_CXX03_LANG

lib/libcxx/include/__new/allocate.h+1-2

...	@@ -13,7 +13,6 @@	...	@@ -13,7 +13,6 @@
13	#include <__cstddef/max_align_t.h>	13	#include <__cstddef/max_align_t.h>
14	#include <__cstddef/size_t.h>	14	#include <__cstddef/size_t.h>
15	#include <__new/align_val_t.h>	15	#include <__new/align_val_t.h>
16	#include <__new/global_new_delete.h> // for _LIBCPP_HAS_SIZED_DEALLOCATION
17	#include <__type_traits/type_identity.h>	16	#include <__type_traits/type_identity.h>
18	#include <__utility/element_count.h>	17	#include <__utility/element_count.h>
19		18
...	@@ -43,7 +42,7 @@ __libcpp_allocate(__element_count __n, [[__maybe_unused__]] size_t __align = _LI	...	@@ -43,7 +42,7 @@ __libcpp_allocate(__element_count __n, [[__maybe_unused__]] size_t __align = _LI
43	return static_cast<_Tp*>(__builtin_operator_new(__size));	42	return static_cast<_Tp*>(__builtin_operator_new(__size));
44	}	43	}
45		44
46	#if _LIBCPP_HAS_SIZED_DEALLOCATION	45	#if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309L
47	# define _LIBCPP_ONLY_IF_SIZED_DEALLOCATION(...) __VA_ARGS__	46	# define _LIBCPP_ONLY_IF_SIZED_DEALLOCATION(...) __VA_ARGS__
48	#else	47	#else
49	# define _LIBCPP_ONLY_IF_SIZED_DEALLOCATION(...) /* nothing */	48	# define _LIBCPP_ONLY_IF_SIZED_DEALLOCATION(...) /* nothing */

lib/libcxx/include/__new/exceptions.h+8-2

...	@@ -17,6 +17,12 @@	...	@@ -17,6 +17,12 @@
17	# pragma GCC system_header	17	# pragma GCC system_header
18	#endif	18	#endif
19		19
		20	// <vcruntime_exception.h> defines its own std::bad_alloc type,
		21	// which we use in order to be ABI-compatible with other STLs on Windows.
		22	#if defined(_LIBCPP_ABI_VCRUNTIME)
		23	# include <vcruntime_exception.h>
		24	#endif
		25
20	_LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD	26	_LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD
21	#if !defined(_LIBCPP_ABI_VCRUNTIME)	27	#if !defined(_LIBCPP_ABI_VCRUNTIME)
22		28
...	@@ -26,7 +32,7 @@ public:	...	@@ -26,7 +32,7 @@ public:
26	_LIBCPP_HIDE_FROM_ABI bad_alloc(const bad_alloc&) _NOEXCEPT = default;	32	_LIBCPP_HIDE_FROM_ABI bad_alloc(const bad_alloc&) _NOEXCEPT = default;
27	_LIBCPP_HIDE_FROM_ABI bad_alloc& operator=(const bad_alloc&) _NOEXCEPT = default;	33	_LIBCPP_HIDE_FROM_ABI bad_alloc& operator=(const bad_alloc&) _NOEXCEPT = default;
28	~bad_alloc() _NOEXCEPT override;	34	~bad_alloc() _NOEXCEPT override;
29	const char* what() const _NOEXCEPT override;	35	[[__nodiscard__]] const char* what() const _NOEXCEPT override;
30	};	36	};
31		37
32	class _LIBCPP_EXPORTED_FROM_ABI bad_array_new_length : public bad_alloc {	38	class _LIBCPP_EXPORTED_FROM_ABI bad_array_new_length : public bad_alloc {
...	@@ -35,7 +41,7 @@ public:	...	@@ -35,7 +41,7 @@ public:
35	_LIBCPP_HIDE_FROM_ABI bad_array_new_length(const bad_array_new_length&) _NOEXCEPT = default;	41	_LIBCPP_HIDE_FROM_ABI bad_array_new_length(const bad_array_new_length&) _NOEXCEPT = default;
36	_LIBCPP_HIDE_FROM_ABI bad_array_new_length& operator=(const bad_array_new_length&) _NOEXCEPT = default;	42	_LIBCPP_HIDE_FROM_ABI bad_array_new_length& operator=(const bad_array_new_length&) _NOEXCEPT = default;
37	~bad_array_new_length() _NOEXCEPT override;	43	~bad_array_new_length() _NOEXCEPT override;
38	const char* what() const _NOEXCEPT override;	44	[[__nodiscard__]] const char* what() const _NOEXCEPT override;
39	};	45	};
40		46
41	#elif defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0 // !_LIBCPP_ABI_VCRUNTIME	47	#elif defined(_HAS_EXCEPTIONS) && _HAS_EXCEPTIONS == 0 // !_LIBCPP_ABI_VCRUNTIME

lib/libcxx/include/__new/global_new_delete.h+4-11

...	@@ -12,7 +12,6 @@	...	@@ -12,7 +12,6 @@
12	#include <__config>	12	#include <__config>
13	#include <__cstddef/size_t.h>	13	#include <__cstddef/size_t.h>
14	#include <__new/align_val_t.h>	14	#include <__new/align_val_t.h>
15	#include <__new/exceptions.h>
16	#include <__new/nothrow_t.h>	15	#include <__new/nothrow_t.h>
17		16
18	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -25,12 +24,6 @@	...	@@ -25,12 +24,6 @@
25	# define _THROW_BAD_ALLOC	24	# define _THROW_BAD_ALLOC
26	#endif	25	#endif
27		26
28	#if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309L
29	# define _LIBCPP_HAS_SIZED_DEALLOCATION 1
30	#else
31	# define _LIBCPP_HAS_SIZED_DEALLOCATION 0
32	#endif
33
34	#if defined(_LIBCPP_ABI_VCRUNTIME)	27	#if defined(_LIBCPP_ABI_VCRUNTIME)
35	# include <new.h>	28	# include <new.h>
36	#else	29	#else
...	@@ -39,7 +32,7 @@	...	@@ -39,7 +32,7 @@
39	_LIBCPP_NOALIAS;	32	_LIBCPP_NOALIAS;
40	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p) _NOEXCEPT;	33	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p) _NOEXCEPT;
41	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;	34	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
42	# if _LIBCPP_HAS_SIZED_DEALLOCATION	35	# if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309L
43	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz) _NOEXCEPT;	36	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz) _NOEXCEPT;
44	# endif	37	# endif
45		38
...	@@ -48,7 +41,7 @@ _LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz) _	...	@@ -48,7 +41,7 @@ _LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz) _
48	_LIBCPP_NOALIAS;	41	_LIBCPP_NOALIAS;
49	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p) _NOEXCEPT;	42	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p) _NOEXCEPT;
50	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;	43	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
51	# if _LIBCPP_HAS_SIZED_DEALLOCATION	44	# if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309L
52	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz) _NOEXCEPT;	45	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz) _NOEXCEPT;
53	# endif	46	# endif
54		47
...	@@ -58,7 +51,7 @@ _LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz)	...	@@ -58,7 +51,7 @@ _LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz)
58	operator new(std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;	51	operator new(std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
59	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::align_val_t) _NOEXCEPT;	52	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::align_val_t) _NOEXCEPT;
60	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;	53	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
61	# if _LIBCPP_HAS_SIZED_DEALLOCATION	54	# if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309L
62	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;	55	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete(void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
63	# endif	56	# endif
64		57
...	@@ -68,7 +61,7 @@ operator new[](std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;	...	@@ -68,7 +61,7 @@ operator new[](std::size_t __sz, std::align_val_t) _THROW_BAD_ALLOC;
68	operator new[](std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;	61	operator new[](std::size_t __sz, std::align_val_t, const std::nothrow_t&) _NOEXCEPT _LIBCPP_NOALIAS;
69	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::align_val_t) _NOEXCEPT;	62	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::align_val_t) _NOEXCEPT;
70	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;	63	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::align_val_t, const std::nothrow_t&) _NOEXCEPT;
71	# if _LIBCPP_HAS_SIZED_DEALLOCATION	64	# if defined(__cpp_sized_deallocation) && __cpp_sized_deallocation >= 201309L
72	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;	65	_LIBCPP_OVERRIDABLE_FUNC_VIS void operator delete[](void* __p, std::size_t __sz, std::align_val_t) _NOEXCEPT;
73	# endif	66	# endif
74	# endif	67	# endif

lib/libcxx/include/__new/interference_size.h-4

 @@ -20,13 +20,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 17
-#  if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
 inline constexpr size_t hardware_destructive_interference_size  = __GCC_DESTRUCTIVE_SIZE;
 inline constexpr size_t hardware_constructive_interference_size = __GCC_CONSTRUCTIVE_SIZE;
-#  endif // defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
 #endif // _LIBCPP_STD_VER >= 17
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__new/launder.h+3-5

 @@ -10,8 +10,6 @@
 #define _LIBCPP___NEW_LAUNDER_H
 #include <__config>
-#include <__type_traits/is_function.h>
-#include <__type_traits/is_void.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 @@ -20,15 +18,15 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Tp>
 [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR _Tp* __launder(_Tp* __p) _NOEXCEPT {
-  static_assert(!(is_function<_Tp>::value), "can't launder functions");
+  // The compiler diagnoses misuses of __builtin_launder, so we don't need to add any static_asserts
-  static_assert(!is_void<_Tp>::value, "can't launder cv-void");
+  // to implement the Mandates.
   return __builtin_launder(__p);
 }
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
 [[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp* launder(_Tp* __p) noexcept {
-  return std::__launder(__p);
+  return __builtin_launder(__p);
 }
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__new/nothrow_t.h+1-1

...	@@ -19,7 +19,7 @@	...	@@ -19,7 +19,7 @@
19	# include <new.h>	19	# include <new.h>
20	#else	20	#else
21	_LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD	21	_LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD
22	struct _LIBCPP_EXPORTED_FROM_ABI nothrow_t {	22	struct nothrow_t {
23	explicit nothrow_t() = default;	23	explicit nothrow_t() = default;
24	};	24	};
25	extern _LIBCPP_EXPORTED_FROM_ABI const nothrow_t nothrow;	25	extern _LIBCPP_EXPORTED_FROM_ABI const nothrow_t nothrow;

lib/libcxx/include/__numeric/gcd_lcm.h+24-34

...	@@ -33,28 +33,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -33,28 +33,26 @@ _LIBCPP_BEGIN_NAMESPACE_STD
33		33
34	#if _LIBCPP_STD_VER >= 17	34	#if _LIBCPP_STD_VER >= 17
35		35
36	template <typename _Result, typename _Source, bool _IsSigned = is_signed<_Source>::value>	36	template <class _Result, class _Source>
37	struct __ct_abs;	37	constexpr _LIBCPP_HIDE_FROM_ABI _Result __abs_in_type(_Source __t) noexcept {
38		38	if constexpr (is_signed_v<_Source>) {
39	template <typename _Result, typename _Source>
40	struct __ct_abs<_Result, _Source, true> {
41	constexpr _LIBCPP_HIDE_FROM_ABI _Result operator()(_Source __t) const noexcept {
42	if (__t >= 0)	39	if (__t >= 0)
43	return __t;	40	return __t;
44	if (__t == numeric_limits<_Source>::min())	41	if (__t == numeric_limits<_Source>::min())
45	return -static_cast<_Result>(__t);	42	return -static_cast<_Result>(__t);
46	return -__t;	43	return -__t;
		44	} else {
		45	return __t;
47	}	46	}
48	};	47	}
49
50	template <typename _Result, typename _Source>
51	struct __ct_abs<_Result, _Source, false> {
52	constexpr _LIBCPP_HIDE_FROM_ABI _Result operator()(_Source __t) const noexcept { return __t; }
53	};
54		48
55	template <class _Tp>	49	template <class _Tp, class _Up>
56	constexpr _LIBCPP_HIDDEN _Tp __gcd(_Tp __a, _Tp __b) {	50	constexpr _LIBCPP_HIDE_FROM_ABI common_type_t<_Tp, _Up> gcd(_Tp __m, _Up __n) {
57	static_assert(!is_signed<_Tp>::value, "");	51	static_assert(is_integral<_Tp>::value && is_integral<_Up>::value, "Arguments to gcd must be integer types");
		52	static_assert(!is_same<__remove_cv_t<_Tp>, bool>::value, "First argument to gcd cannot be bool");
		53	static_assert(!is_same<__remove_cv_t<_Up>, bool>::value, "Second argument to gcd cannot be bool");
		54	using _Rp = common_type_t<_Tp, _Up>;
		55	using _Wp = make_unsigned_t<_Rp>;
58		56
59	// Using Binary GCD algorithm https://en.wikipedia.org/wiki/Binary_GCD_algorithm, based on an implementation	57	// Using Binary GCD algorithm https://en.wikipedia.org/wiki/Binary_GCD_algorithm, based on an implementation
60	// from https://lemire.me/blog/2024/04/13/greatest-common-divisor-the-extended-euclidean-algorithm-and-speed/	58	// from https://lemire.me/blog/2024/04/13/greatest-common-divisor-the-extended-euclidean-algorithm-and-speed/
...	@@ -67,22 +65,25 @@ constexpr _LIBCPP_HIDDEN _Tp __gcd(_Tp __a, _Tp __b) {	...	@@ -67,22 +65,25 @@ constexpr _LIBCPP_HIDDEN _Tp __gcd(_Tp __a, _Tp __b) {
67	//	65	//
68	// And standard gcd algorithm where instead of modulo, minus is used.	66	// And standard gcd algorithm where instead of modulo, minus is used.
69		67
		68	auto __a = static_cast<_Wp>(std::__abs_in_type<_Rp>(__m));
		69	auto __b = static_cast<_Wp>(std::__abs_in_type<_Rp>(__n));
		70
70	if (__a < __b) {	71	if (__a < __b) {
71	_Tp __tmp = __b;	72	_Wp __tmp = __b;
72	__b = __a;	73	__b = __a;
73	__a = __tmp;	74	__a = __tmp;
74	}	75	}
75	if (__b == 0)	76	if (__b == 0)
76	return __a;	77	return static_cast<_Rp>(__a);
77	__a %= __b; // Make both argument of the same size, and early result in the easy case.	78	__a %= __b; // Make both argument of the same size, and early result in the easy case.
78	if (__a == 0)	79	if (__a == 0)
79	return __b;	80	return static_cast<_Rp>(__b);
80		81
81	_Tp __c = __a \| __b;	82	_Wp __c = __a \| __b;
82	int __shift = std::__countr_zero(__c);	83	int __shift = std::__countr_zero(__c);
83	__a >>= std::__countr_zero(__a);	84	__a >>= std::__countr_zero(__a);
84	do {	85	do {
85	_Tp __t = __b >> std::__countr_zero(__b);	86	_Wp __t = __b >> std::__countr_zero(__b);
86	if (__a > __t) {	87	if (__a > __t) {
87	__b = __a - __t;	88	__b = __a - __t;
88	__a = __t;	89	__a = __t;
...	@@ -90,18 +91,7 @@ constexpr _LIBCPP_HIDDEN _Tp __gcd(_Tp __a, _Tp __b) {	...	@@ -90,18 +91,7 @@ constexpr _LIBCPP_HIDDEN _Tp __gcd(_Tp __a, _Tp __b) {
90	__b = __t - __a;	91	__b = __t - __a;
91	}	92	}
92	} while (__b != 0);	93	} while (__b != 0);
93	return __a << __shift;	94	return static_cast<_Rp>(__a << __shift);
94	}
95
96	template <class _Tp, class _Up>
97	constexpr _LIBCPP_HIDE_FROM_ABI common_type_t<_Tp, _Up> gcd(_Tp __m, _Up __n) {
98	static_assert(is_integral<_Tp>::value && is_integral<_Up>::value, "Arguments to gcd must be integer types");
99	static_assert(!is_same<__remove_cv_t<_Tp>, bool>::value, "First argument to gcd cannot be bool");
100	static_assert(!is_same<__remove_cv_t<_Up>, bool>::value, "Second argument to gcd cannot be bool");
101	using _Rp = common_type_t<_Tp, _Up>;
102	using _Wp = make_unsigned_t<_Rp>;
103	return static_cast<_Rp>(
104	std::__gcd(static_cast<_Wp>(__ct_abs<_Rp, _Tp>()(__m)), static_cast<_Wp>(__ct_abs<_Rp, _Up>()(__n))));
105	}	95	}
106		96
107	template <class _Tp, class _Up>	97	template <class _Tp, class _Up>
...	@@ -113,8 +103,8 @@ constexpr _LIBCPP_HIDE_FROM_ABI common_type_t<_Tp, _Up> lcm(_Tp __m, _Up __n) {	...	@@ -113,8 +103,8 @@ constexpr _LIBCPP_HIDE_FROM_ABI common_type_t<_Tp, _Up> lcm(_Tp __m, _Up __n) {
113	return 0;	103	return 0;
114		104
115	using _Rp = common_type_t<_Tp, _Up>;	105	using _Rp = common_type_t<_Tp, _Up>;
116	_Rp __val1 = __ct_abs<_Rp, _Tp>()(__m) / std::gcd(__m, __n);	106	_Rp __val1 = std::__abs_in_type<_Rp>(__m) / std::gcd(__m, __n);
117	_Rp __val2 = __ct_abs<_Rp, _Up>()(__n);	107	_Rp __val2 = std::__abs_in_type<_Rp>(__n);
118	_Rp __res;	108	_Rp __res;
119	[[maybe_unused]] bool __overflow = __builtin_mul_overflow(__val1, __val2, std::addressof(__res));	109	[[maybe_unused]] bool __overflow = __builtin_mul_overflow(__val1, __val2, std::addressof(__res));
120	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(!__overflow, "Overflow in lcm");	110	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(!__overflow, "Overflow in lcm");

lib/libcxx/include/__numeric/midpoint.h+9-14

 @@ -12,16 +12,13 @@
 #include <__config>
 #include <__cstddef/ptrdiff_t.h>
-#include <__type_traits/enable_if.h>
 #include <__type_traits/is_floating_point.h>
 #include <__type_traits/is_integral.h>
-#include <__type_traits/is_null_pointer.h>
 #include <__type_traits/is_object.h>
-#include <__type_traits/is_pointer.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/is_void.h>
 #include <__type_traits/make_unsigned.h>
-#include <__type_traits/remove_pointer.h>
+#include <__type_traits/remove_cv.h>
 #include <limits>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 @@ -35,8 +32,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<is_integral_v<_Tp> && !is_same_v<bool, _Tp> && !is_null_pointer_v<_Tp>, _Tp>
+  requires(is_integral_v<_Tp> && !is_same_v<remove_cv_t<_Tp>, bool>)
-midpoint(_Tp __a, _Tp __b) noexcept _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
+[[nodiscard]]
+_LIBCPP_HIDE_FROM_ABI constexpr _Tp midpoint(_Tp __a, _Tp __b) noexcept _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
   using _Up                = make_unsigned_t<_Tp>;
   constexpr _Up __bitshift = numeric_limits<_Up>::digits - 1;
 @@ -48,23 +46,20 @@ midpoint(_Tp __a, _Tp __b) noexcept _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK
   return __a + __half_diff;
 }
-template <class _Tp, enable_if_t<is_object_v<_Tp> && !is_void_v<_Tp> && (sizeof(_Tp) > 0), int> = 0>
+template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp* midpoint(_Tp* __a, _Tp* __b) noexcept {
+  requires(is_object_v<_Tp> && (sizeof(_Tp) > 0))
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* midpoint(_Tp* __a, _Tp* __b) noexcept {
   return __a + std::midpoint(ptrdiff_t(0), __b - __a);
 }
-template <typename _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr int __sign(_Tp __val) {
-  return (_Tp(0) < __val) - (__val < _Tp(0));
-}
 template <typename _Fp>
 _LIBCPP_HIDE_FROM_ABI constexpr _Fp __fp_abs(_Fp __f) {
   return __f >= 0 ? __f : -__f;
 }
 template <class _Fp>
-_LIBCPP_HIDE_FROM_ABI constexpr enable_if_t<is_floating_point_v<_Fp>, _Fp> midpoint(_Fp __a, _Fp __b) noexcept {
+  requires(is_floating_point_v<_Fp>)
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Fp midpoint(_Fp __a, _Fp __b) noexcept {
   constexpr _Fp __lo = numeric_limits<_Fp>::min() * 2;
   constexpr _Fp __hi = numeric_limits<_Fp>::max() / 2;

lib/libcxx/include/__numeric/pstl.h+2-2

...	@@ -70,7 +70,7 @@ template <class _ExecutionPolicy,	...	@@ -70,7 +70,7 @@ template <class _ExecutionPolicy,
70	class _ForwardIterator,	70	class _ForwardIterator,
71	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	71	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
72	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	72	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
73	_LIBCPP_HIDE_FROM_ABI __iter_value_type<_ForwardIterator>	73	_LIBCPP_HIDE_FROM_ABI __iterator_value_type<_ForwardIterator>
74	reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {	74	reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last) {
75	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");	75	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "reduce requires ForwardIterators");
76	using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;	76	using _Implementation = __pstl::__dispatch<__pstl::__reduce, __pstl::__current_configuration, _RawPolicy>;
...	@@ -78,7 +78,7 @@ reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator _	...	@@ -78,7 +78,7 @@ reduce(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator _
78	std::forward<_ExecutionPolicy>(__policy),	78	std::forward<_ExecutionPolicy>(__policy),
79	std::move(__first),	79	std::move(__first),
80	std::move(__last),	80	std::move(__last),
81	__iter_value_type<_ForwardIterator>(),	81	__iterator_value_type<_ForwardIterator>(),
82	plus{});	82	plus{});
83	}	83	}
84		84

lib/libcxx/include/__numeric/saturation_arithmetic.h+13-5

 @@ -30,6 +30,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <__signed_or_unsigned_integer _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp __add_sat(_Tp __x, _Tp __y) noexcept {
+#  if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 2101
+  return __builtin_elementwise_add_sat(__x, __y);
+#  else
   if (_Tp __sum; !__builtin_add_overflow(__x, __y, std::addressof(__sum)))
     return __sum;
   // Handle overflow
 @@ -44,10 +47,14 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __add_sat(_Tp __x, _Tp __y) noexcept {
       // Overflows if  (x < 0 && y < 0)
       return std::numeric_limits<_Tp>::min();
   }
+#  endif
 }
 template <__signed_or_unsigned_integer _Tp>
 _LIBCPP_HIDE_FROM_ABI constexpr _Tp __sub_sat(_Tp __x, _Tp __y) noexcept {
+#  if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 2101
+  return __builtin_elementwise_sub_sat(__x, __y);
+#  else
   if (_Tp __sub; !__builtin_sub_overflow(__x, __y, std::addressof(__sub)))
     return __sub;
   // Handle overflow
 @@ -63,6 +70,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Tp __sub_sat(_Tp __x, _Tp __y) noexcept {
       // Overflows if (x < 0 && y > 0)
       return std::numeric_limits<_Tp>::min();
   }
+#  endif
 }
 template <__signed_or_unsigned_integer _Tp>
 @@ -113,27 +121,27 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Rp __saturate_cast(_Tp __x) noexcept {
 #if _LIBCPP_STD_VER >= 26
 template <__signed_or_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp add_sat(_Tp __x, _Tp __y) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp add_sat(_Tp __x, _Tp __y) noexcept {
   return std::__add_sat(__x, __y);
 }
 template <__signed_or_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp sub_sat(_Tp __x, _Tp __y) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp sub_sat(_Tp __x, _Tp __y) noexcept {
   return std::__sub_sat(__x, __y);
 }
 template <__signed_or_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp mul_sat(_Tp __x, _Tp __y) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp mul_sat(_Tp __x, _Tp __y) noexcept {
   return std::__mul_sat(__x, __y);
 }
 template <__signed_or_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp div_sat(_Tp __x, _Tp __y) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp div_sat(_Tp __x, _Tp __y) noexcept {
   return std::__div_sat(__x, __y);
 }
 template <__signed_or_unsigned_integer _Rp, __signed_or_unsigned_integer _Tp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Rp saturate_cast(_Tp __x) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Rp saturate_cast(_Tp __x) noexcept {
   return std::__saturate_cast<_Rp>(__x);
 }

lib/libcxx/include/__ostream/basic_ostream.h+8-8

...	@@ -53,7 +53,7 @@ public:	...	@@ -53,7 +53,7 @@ public:
53	typedef typename traits_type::off_type off_type;	53	typedef typename traits_type::off_type off_type;
54		54
55	// 27.7.2.2 Constructor/destructor:	55	// 27.7.2.2 Constructor/destructor:
56	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {	56	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 explicit basic_ostream(basic_streambuf<char_type, traits_type>* __sb) {
57	this->init(__sb);	57	this->init(__sb);
58	}	58	}
59	~basic_ostream() override;	59	~basic_ostream() override;
...	@@ -67,7 +67,7 @@ protected:	...	@@ -67,7 +67,7 @@ protected:
67	// 27.7.2.3 Assign/swap	67	// 27.7.2.3 Assign/swap
68	inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);	68	inline _LIBCPP_HIDE_FROM_ABI basic_ostream& operator=(basic_ostream&& __rhs);
69		69
70	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_ostream& __rhs) {	70	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void swap(basic_ostream& __rhs) {
71	basic_ios<char_type, traits_type>::swap(__rhs);	71	basic_ios<char_type, traits_type>::swap(__rhs);
72	}	72	}
73		73
...	@@ -76,17 +76,17 @@ public:	...	@@ -76,17 +76,17 @@ public:
76	class sentry;	76	class sentry;
77		77
78	// 27.7.2.6 Formatted output:	78	// 27.7.2.6 Formatted output:
79	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {	79	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_ostream& operator<<(basic_ostream& (*__pf)(basic_ostream&)) {
80	return __pf(*this);	80	return __pf(*this);
81	}	81	}
82		82
83	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream&	83	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_ostream&
84	operator<<(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {	84	operator<<(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
85	__pf(*this);	85	__pf(*this);
86	return *this;	86	return *this;
87	}	87	}
88		88
89	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {	89	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_ostream& operator<<(ios_base& (*__pf)(ios_base&)) {
90	__pf(*this);	90	__pf(*this);
91	return *this;	91	return *this;
92	}	92	}
...	@@ -174,9 +174,9 @@ public:	...	@@ -174,9 +174,9 @@ public:
174	basic_ostream& flush();	174	basic_ostream& flush();
175		175
176	// 27.7.2.5 seeks:	176	// 27.7.2.5 seeks:
177	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type tellp();	177	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 pos_type tellp();
178	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(pos_type __pos);	178	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_ostream& seekp(pos_type __pos);
179	inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);	179	inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_ostream& seekp(off_type __off, ios_base::seekdir __dir);
180		180
181	protected:	181	protected:
182	_LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize	182	_LIBCPP_HIDE_FROM_ABI basic_ostream() {} // extension, intentially does not initialize

lib/libcxx/include/__pstl/backends/default.h+14-14

lib/libcxx/include/__pstl/backends/libdispatch.h+2-2

...	@@ -269,7 +269,7 @@ struct __cpu_traits<__libdispatch_backend_tag> {	...	@@ -269,7 +269,7 @@ struct __cpu_traits<__libdispatch_backend_tag> {
269	return __empty{};	269	return __empty{};
270	}	270	}
271		271
272	using _Value = __iter_value_type<_RandomAccessIterator>;	272	using _Value = __iterator_value_type<_RandomAccessIterator>;
273		273
274	auto __destroy = [__size](_Value* __ptr) {	274	auto __destroy = [__size](_Value* __ptr) {
275	std::destroy_n(__ptr, __size);	275	std::destroy_n(__ptr, __size);
...	@@ -282,7 +282,7 @@ struct __cpu_traits<__libdispatch_backend_tag> {	...	@@ -282,7 +282,7 @@ struct __cpu_traits<__libdispatch_backend_tag> {
282	// Initialize all elements to a moved-from state	282	// Initialize all elements to a moved-from state
283	// TODO: Don't do this - this can be done in the first merge - see https://llvm.org/PR63928	283	// TODO: Don't do this - this can be done in the first merge - see https://llvm.org/PR63928
284	std::__construct_at(__values.get(), std::move(*__first));	284	std::__construct_at(__values.get(), std::move(*__first));
285	for (__iter_diff_t<_RandomAccessIterator> __i = 1; __i != __size; ++__i) {	285	for (__iterator_difference_type<_RandomAccessIterator> __i = 1; __i != __size; ++__i) {
286	std::__construct_at(__values.get() + __i, std::move(__values.get()[__i - 1]));	286	std::__construct_at(__values.get() + __i, std::move(__values.get()[__i - 1]));
287	}	287	}
288	*__first = std::move(__values.get()[__size - 1]);	288	*__first = std::move(__values.get()[__size - 1]);

lib/libcxx/include/__pstl/cpu_algos/find_if.h+1-1

...	@@ -119,7 +119,7 @@ struct __cpu_parallel_find_if {	...	@@ -119,7 +119,7 @@ struct __cpu_parallel_find_if {
119	true);	119	true);
120	} else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&	120	} else if constexpr (__is_unsequenced_execution_policy_v<_RawExecutionPolicy> &&
121	__has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {	121	__has_random_access_iterator_category_or_concept<_ForwardIterator>::value) {
122	using __diff_t = __iter_diff_t<_ForwardIterator>;	122	using __diff_t = __iterator_difference_type<_ForwardIterator>;
123	return __pstl::__simd_first<_Backend>(	123	return __pstl::__simd_first<_Backend>(
124	__first, __diff_t(0), __last - __first, [&__pred](_ForwardIterator __iter, __diff_t __i) {	124	__first, __diff_t(0), __last - __first, [&__pred](_ForwardIterator __iter, __diff_t __i) {
125	return __pred(__iter[__i]);	125	return __pred(__iter[__i]);

lib/libcxx/include/__pstl/cpu_algos/transform.h+5-6

 @@ -84,9 +84,8 @@ struct __cpu_parallel_transform {
           __first,
           __last - __first,
           __result,
-          [&](__iter_reference<_ForwardIterator> __in_value, __iter_reference<_ForwardOutIterator> __out_value) {
+          [&](__iterator_reference<_ForwardIterator> __in_value,
-            __out_value = __op(__in_value);
+              __iterator_reference<_ForwardOutIterator> __out_value) { __out_value = __op(__in_value); });
-          });
     } else {
       return std::transform(__first, __last, __result, __op);
     }
 @@ -138,9 +137,9 @@ struct __cpu_parallel_transform_binary {
           __last1 - __first1,
           __first2,
           __result,
-          [&](__iter_reference<_ForwardIterator1> __in1,
+          [&](__iterator_reference<_ForwardIterator1> __in1,
-              __iter_reference<_ForwardIterator2> __in2,
+              __iterator_reference<_ForwardIterator2> __in2,
-              __iter_reference<_ForwardOutIterator> __out_value) { __out_value = __op(__in1, __in2); });
+              __iterator_reference<_ForwardOutIterator> __out_value) { __out_value = __op(__in1, __in2); });
     } else {
       return std::transform(__first1, __last1, __first2, __result, __op);
     }

lib/libcxx/include/__pstl/cpu_algos/transform_reduce.h+5-4

...	@@ -148,9 +148,10 @@ struct __cpu_parallel_transform_reduce_binary {	...	@@ -148,9 +148,10 @@ struct __cpu_parallel_transform_reduce_binary {
148	__has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&	148	__has_random_access_iterator_category_or_concept<_ForwardIterator1>::value &&
149	__has_random_access_iterator_category_or_concept<_ForwardIterator2>::value) {	149	__has_random_access_iterator_category_or_concept<_ForwardIterator2>::value) {
150	return __pstl::__simd_transform_reduce<_Backend>(	150	return __pstl::__simd_transform_reduce<_Backend>(
151	__last1 - __first1, std::move(__init), std::move(__reduce), [&](__iter_diff_t<_ForwardIterator1> __i) {	151	__last1 - __first1,
152	return __transform(__first1[__i], __first2[__i]);	152	std::move(__init),
153	});	153	std::move(__reduce),
		154	[&](__iterator_difference_type<_ForwardIterator1> __i) { return __transform(__first1[__i], __first2[__i]); });
154	} else {	155	} else {
155	return std::transform_reduce(	156	return std::transform_reduce(
156	std::move(__first1),	157	std::move(__first1),
...	@@ -200,7 +201,7 @@ struct __cpu_parallel_transform_reduce {	...	@@ -200,7 +201,7 @@ struct __cpu_parallel_transform_reduce {
200	__last - __first,	201	__last - __first,
201	std::move(__init),	202	std::move(__init),
202	std::move(__reduce),	203	std::move(__reduce),
203	[=, &__transform](__iter_diff_t<_ForwardIterator> __i) { return __transform(__first[__i]); });	204	[=, &__transform](__iterator_difference_type<_ForwardIterator> __i) { return __transform(__first[__i]); });
204	} else {	205	} else {
205	return std::transform_reduce(	206	return std::transform_reduce(
206	std::move(__first), std::move(__last), std::move(__init), std::move(__reduce), std::move(__transform));	207	std::move(__first), std::move(__last), std::move(__init), std::move(__reduce), std::move(__transform));

lib/libcxx/include/__random/binomial_distribution.h+10-4

 @@ -97,13 +97,19 @@ public:
   }
 };
-// The LLVM C library provides this with conflicting `noexcept` attributes.
+// Some libc declares the math functions to be `noexcept`.
-#if !defined(_LIBCPP_MSVCRT_LIKE) && !defined(__LLVM_LIBC__)
+#if _LIBCPP_GLIBC_PREREQ(2, 8) || defined(__LLVM_LIBC__)
-extern "C" double lgamma_r(double, int*);
+#  define _LIBCPP_LGAMMA_R_NOEXCEPT _NOEXCEPT
+#else
+#  define _LIBCPP_LGAMMA_R_NOEXCEPT
+#endif
+#if !defined(_LIBCPP_MSVCRT_LIKE)
+extern "C" double lgamma_r(double, int*) _LIBCPP_LGAMMA_R_NOEXCEPT;
 #endif
 inline _LIBCPP_HIDE_FROM_ABI double __libcpp_lgamma(double __d) {
-#if defined(_LIBCPP_MSVCRT_LIKE) || defined(__LLVM_LIBC__)
+#if defined(_LIBCPP_MSVCRT_LIKE)
   return lgamma(__d);
 #else
   int __sign;

lib/libcxx/include/__random/mersenne_twister_engine.h+50-154

...	@@ -62,24 +62,6 @@ _LIBCPP_HIDE_FROM_ABI bool	...	@@ -62,24 +62,6 @@ _LIBCPP_HIDE_FROM_ABI bool
62	operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,	62	operator==(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
63	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);	63	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
64		64
65	template <class _UInt,
66	size_t _Wp,
67	size_t _Np,
68	size_t _Mp,
69	size_t _Rp,
70	_UInt _Ap,
71	size_t _Up,
72	_UInt _Dp,
73	size_t _Sp,
74	_UInt _Bp,
75	size_t _Tp,
76	_UInt _Cp,
77	size_t _Lp,
78	_UInt _Fp>
79	_LIBCPP_HIDE_FROM_ABI bool
80	operator!=(const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
81	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
82
83	template <class _CharT,	65	template <class _CharT,
84	class _Traits,	66	class _Traits,
85	class _UInt,	67	class _UInt,
...	@@ -194,14 +176,31 @@ public:	...	@@ -194,14 +176,31 @@ public:
194	_LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(_Sseq& __q) {	176	_LIBCPP_HIDE_FROM_ABI explicit mersenne_twister_engine(_Sseq& __q) {
195	seed(__q);	177	seed(__q);
196	}	178	}
197	_LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed);	179	_LIBCPP_HIDE_FROM_ABI void seed(result_type __sd = default_seed) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK {
		180	__x_[0] = __sd & _Max;
		181	for (size_t __i = 1; __i < __n; ++__i)
		182	__x_[__i] = (__f * (__x_[__i - 1] ^ __rshift<__w - 2>(__x_[__i - 1])) + __i) & _Max;
		183	__i_ = 0;
		184	}
198	template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>	185	template <class _Sseq, __enable_if_t<__is_seed_sequence<_Sseq, mersenne_twister_engine>::value, int> = 0>
199	_LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {	186	_LIBCPP_HIDE_FROM_ABI void seed(_Sseq& __q) {
200	__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());	187	__seed(__q, integral_constant<unsigned, 1 + (__w - 1) / 32>());
201	}	188	}
202		189
203	// generating functions	190	// generating functions
204	_LIBCPP_HIDE_FROM_ABI result_type operator()();	191	_LIBCPP_HIDE_FROM_ABI result_type operator()() {
		192	const size_t __j = (__i_ + 1) % __n;
		193	const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
		194	const result_type __yp = (__x_[__i_] & ~__mask) \| (__x_[__j] & __mask);
		195	const size_t __k = (__i_ + __m) % __n;
		196	__x_[__i_] = __x_[__k] ^ __rshift<1>(__yp) ^ (__a * (__yp & 1));
		197	result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
		198	__i_ = __j;
		199	__z ^= __lshift<__s>(__z) & __b;
		200	__z ^= __lshift<__t>(__z) & __c;
		201	return __z ^ __rshift<__l>(__z);
		202	}
		203
205	_LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {	204	_LIBCPP_HIDE_FROM_ABI void discard(unsigned long long __z) {
206	for (; __z; --__z)	205	for (; __z; --__z)
207	operator()();	206	operator()();
...	@@ -225,24 +224,6 @@ public:	...	@@ -225,24 +224,6 @@ public:
225	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,	224	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
226	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);	225	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
227		226
228	template <class _UInt,
229	size_t _Wp,
230	size_t _Np,
231	size_t _Mp,
232	size_t _Rp,
233	_UInt _Ap,
234	size_t _Up,
235	_UInt _Dp,
236	size_t _Sp,
237	_UInt _Bp,
238	size_t _Tp,
239	_UInt _Cp,
240	size_t _Lp,
241	_UInt _Fp>
242	friend bool operator!=(
243	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __x,
244	const mersenne_twister_engine<_UInt, _Wp, _Np, _Mp, _Rp, _Ap, _Up, _Dp, _Sp, _Bp, _Tp, _Cp, _Lp, _Fp>& __y);
245
246	template <class _CharT,	227	template <class _CharT,
247	class _Traits,	228	class _Traits,
248	class _UInt,	229	class _UInt,
...	@@ -285,9 +266,38 @@ public:	...	@@ -285,9 +266,38 @@ public:
285		266
286	private:	267	private:
287	template <class _Sseq>	268	template <class _Sseq>
288	_LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>);	269	_LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 1>) {
		270	const unsigned __k = 1;
		271	uint32_t __ar[__n * __k];
		272	__q.generate(__ar, __ar + __n * __k);
		273	for (size_t __i = 0; __i < __n; ++__i)
		274	__x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
		275	const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
		276	__i_ = 0;
		277	if ((__x_[0] & ~__mask) == 0) {
		278	for (size_t __i = 1; __i < __n; ++__i)
		279	if (__x_[__i] != 0)
		280	return;
		281	__x_[0] = result_type(1) << (__w - 1);
		282	}
		283	}
		284
289	template <class _Sseq>	285	template <class _Sseq>
290	_LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>);	286	_LIBCPP_HIDE_FROM_ABI void __seed(_Sseq& __q, integral_constant<unsigned, 2>) {
		287	const unsigned __k = 2;
		288	uint32_t __ar[__n * __k];
		289	__q.generate(__ar, __ar + __n * __k);
		290	for (size_t __i = 0; __i < __n; ++__i)
		291	__x_[__i] = static_cast<result_type>((__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
		292	const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
		293	__i_ = 0;
		294	if ((__x_[0] & ~__mask) == 0) {
		295	for (size_t __i = 1; __i < __n; ++__i)
		296	if (__x_[__i] != 0)
		297	return;
		298	__x_[0] = result_type(1) << (__w - 1);
		299	}
		300	}
291		301
292	template <size_t __count,	302	template <size_t __count,
293	__enable_if_t<__count< __w, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) {	303	__enable_if_t<__count< __w, int> = 0> _LIBCPP_HIDE_FROM_ABI static result_type __lshift(result_type __x) {
...	@@ -310,120 +320,6 @@ private:	...	@@ -310,120 +320,6 @@ private:
310	}	320	}
311	};	321	};
312		322
313	template <class _UIntType,
314	size_t __w,
315	size_t __n,
316	size_t __m,
317	size_t __r,
318	_UIntType __a,
319	size_t __u,
320	_UIntType __d,
321	size_t __s,
322	_UIntType __b,
323	size_t __t,
324	_UIntType __c,
325	size_t __l,
326	_UIntType __f>
327	void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::seed(
328	result_type __sd) _LIBCPP_DISABLE_UBSAN_UNSIGNED_INTEGER_CHECK { // __w >= 2
329	__x_[0] = __sd & _Max;
330	for (size_t __i = 1; __i < __n; ++__i)
331	__x_[__i] = (__f * (__x_[__i - 1] ^ __rshift<__w - 2>(__x_[__i - 1])) + __i) & _Max;
332	__i_ = 0;
333	}
334
335	template <class _UIntType,
336	size_t __w,
337	size_t __n,
338	size_t __m,
339	size_t __r,
340	_UIntType __a,
341	size_t __u,
342	_UIntType __d,
343	size_t __s,
344	_UIntType __b,
345	size_t __t,
346	_UIntType __c,
347	size_t __l,
348	_UIntType __f>
349	template <class _Sseq>
350	void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed(
351	_Sseq& __q, integral_constant<unsigned, 1>) {
352	const unsigned __k = 1;
353	uint32_t __ar[__n * __k];
354	__q.generate(__ar, __ar + __n * __k);
355	for (size_t __i = 0; __i < __n; ++__i)
356	__x_[__i] = static_cast<result_type>(__ar[__i] & _Max);
357	const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
358	__i_ = 0;
359	if ((__x_[0] & ~__mask) == 0) {
360	for (size_t __i = 1; __i < __n; ++__i)
361	if (__x_[__i] != 0)
362	return;
363	__x_[0] = result_type(1) << (__w - 1);
364	}
365	}
366
367	template <class _UIntType,
368	size_t __w,
369	size_t __n,
370	size_t __m,
371	size_t __r,
372	_UIntType __a,
373	size_t __u,
374	_UIntType __d,
375	size_t __s,
376	_UIntType __b,
377	size_t __t,
378	_UIntType __c,
379	size_t __l,
380	_UIntType __f>
381	template <class _Sseq>
382	void mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::__seed(
383	_Sseq& __q, integral_constant<unsigned, 2>) {
384	const unsigned __k = 2;
385	uint32_t __ar[__n * __k];
386	__q.generate(__ar, __ar + __n * __k);
387	for (size_t __i = 0; __i < __n; ++__i)
388	__x_[__i] = static_cast<result_type>((__ar[2 * __i] + ((uint64_t)__ar[2 * __i + 1] << 32)) & _Max);
389	const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
390	__i_ = 0;
391	if ((__x_[0] & ~__mask) == 0) {
392	for (size_t __i = 1; __i < __n; ++__i)
393	if (__x_[__i] != 0)
394	return;
395	__x_[0] = result_type(1) << (__w - 1);
396	}
397	}
398
399	template <class _UIntType,
400	size_t __w,
401	size_t __n,
402	size_t __m,
403	size_t __r,
404	_UIntType __a,
405	size_t __u,
406	_UIntType __d,
407	size_t __s,
408	_UIntType __b,
409	size_t __t,
410	_UIntType __c,
411	size_t __l,
412	_UIntType __f>
413	_UIntType
414	mersenne_twister_engine<_UIntType, __w, __n, __m, __r, __a, __u, __d, __s, __b, __t, __c, __l, __f>::operator()() {
415	const size_t __j = (__i_ + 1) % __n;
416	const result_type __mask = __r == _Dt ? result_type(~0) : (result_type(1) << __r) - result_type(1);
417	const result_type __yp = (__x_[__i_] & ~__mask) \| (__x_[__j] & __mask);
418	const size_t __k = (__i_ + __m) % __n;
419	__x_[__i_] = __x_[__k] ^ __rshift<1>(__yp) ^ (__a * (__yp & 1));
420	result_type __z = __x_[__i_] ^ (__rshift<__u>(__x_[__i_]) & __d);
421	__i_ = __j;
422	__z ^= __lshift<__s>(__z) & __b;
423	__z ^= __lshift<__t>(__z) & __c;
424	return __z ^ __rshift<__l>(__z);
425	}
426
427	template <class _UInt,	323	template <class _UInt,
428	size_t _Wp,	324	size_t _Wp,
429	size_t _Np,	325	size_t _Np,

lib/libcxx/include/__random/piecewise_constant_distribution.h+3-2

 @@ -9,9 +9,11 @@
 #ifndef _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_CONSTANT_DISTRIBUTION_H
+#include <__algorithm/copy_n.h>
 #include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__cstddef/ptrdiff_t.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <__vector/vector.h>
 @@ -190,8 +192,7 @@ piecewise_constant_distribution<_RealType>::param_type::param_type(
     __areas_.assign(1, 0.0);
   } else {
     __densities_.reserve(__b_.size() - 1);
-    for (size_t __i = 0; __i < __b_.size() - 1; ++__i, ++__f_w)
+    std::copy_n(__f_w, __b_.size() - 1, std::back_inserter(__densities_));
-      __densities_.push_back(*__f_w);
     __init();
   }
 }

lib/libcxx/include/__random/piecewise_linear_distribution.h+3-2

 @@ -9,9 +9,11 @@
 #ifndef _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
 #define _LIBCPP___RANDOM_PIECEWISE_LINEAR_DISTRIBUTION_H
+#include <__algorithm/copy_n.h>
 #include <__algorithm/upper_bound.h>
 #include <__config>
 #include <__cstddef/ptrdiff_t.h>
+#include <__iterator/back_insert_iterator.h>
 #include <__random/is_valid.h>
 #include <__random/uniform_real_distribution.h>
 #include <__vector/comparison.h>
 @@ -194,8 +196,7 @@ piecewise_linear_distribution<_RealType>::param_type::param_type(
     __areas_.assign(1, 0.0);
   } else {
     __densities_.reserve(__b_.size());
-    for (size_t __i = 0; __i < __b_.size(); ++__i, ++__f_w)
+    std::copy_n(__f_w, __b_.size(), std::back_inserter(__densities_));
-      __densities_.push_back(*__f_w);
     __init();
   }
 }

lib/libcxx/include/__ranges/adjacent_transform_view.h created+406

...	@@ -0,0 +1,406 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___RANGES_ADJACENT_TRANSFORM_VIEW_H
11	#define _LIBCPP___RANGES_ADJACENT_TRANSFORM_VIEW_H
12
13	#include <__config>
14
15	#include <__algorithm/min.h>
16	#include <__compare/three_way_comparable.h>
17	#include <__concepts/constructible.h>
18	#include <__concepts/convertible_to.h>
19	#include <__concepts/derived_from.h>
20	#include <__concepts/equality_comparable.h>
21	#include <__concepts/invocable.h>
22	#include <__cstddef/size_t.h>
23	#include <__functional/bind_back.h>
24	#include <__functional/invoke.h>
25	#include <__functional/operations.h>
26	#include <__iterator/concepts.h>
27	#include <__iterator/incrementable_traits.h>
28	#include <__iterator/iter_move.h>
29	#include <__iterator/iter_swap.h>
30	#include <__iterator/iterator_traits.h>
31	#include <__iterator/next.h>
32	#include <__iterator/prev.h>
33	#include <__memory/addressof.h>
34	#include <__ranges/access.h>
35	#include <__ranges/adjacent_view.h>
36	#include <__ranges/all.h>
37	#include <__ranges/concepts.h>
38	#include <__ranges/empty_view.h>
39	#include <__ranges/movable_box.h>
40	#include <__ranges/range_adaptor.h>
41	#include <__ranges/size.h>
42	#include <__ranges/view_interface.h>
43	#include <__ranges/zip_transform_view.h>
44	#include <__type_traits/common_type.h>
45	#include <__type_traits/decay.h>
46	#include <__type_traits/is_nothrow_constructible.h>
47	#include <__type_traits/is_object.h>
48	#include <__type_traits/is_referenceable.h>
49	#include <__type_traits/make_unsigned.h>
50	#include <__type_traits/maybe_const.h>
51	#include <__utility/declval.h>
52	#include <__utility/forward.h>
53	#include <__utility/in_place.h>
54	#include <__utility/integer_sequence.h>
55	#include <__utility/move.h>
56
57	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
58	# pragma GCC system_header
59	#endif
60
61	_LIBCPP_PUSH_MACROS
62	#include <__undef_macros>
63
64	_LIBCPP_BEGIN_NAMESPACE_STD
65
66	#if _LIBCPP_STD_VER >= 23
67
68	namespace ranges {
69
70	template <class _Fn, size_t _Np>
71	struct __apply_n {
72	template <class _Tp, size_t... _Is>
73	static auto __apply(index_sequence<_Is...>) -> invoke_result_t<_Fn, decltype((void)_Is, std::declval<_Tp>())...>;
74
75	template <class _Tp>
76	static auto operator()(_Tp&&) -> decltype(__apply<_Tp>(make_index_sequence<_Np>{}));
77	};
78
79	template <forward_range _View, move_constructible _Fn, size_t _Np>
80	requires view<_View> && (_Np > 0) && is_object_v<_Fn> &&
81	regular_invocable<__apply_n<_Fn&, _Np>, range_reference_t<_View>> &&
82	__referenceable<invoke_result_t<__apply_n<_Fn&, _Np>, range_reference_t<_View>>>
83	class adjacent_transform_view : public view_interface<adjacent_transform_view<_View, _Fn, _Np>> {
84	private:
85	_LIBCPP_NO_UNIQUE_ADDRESS adjacent_view<_View, _Np> __inner_;
86	_LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __fun_;
87
88	using _InnerView _LIBCPP_NODEBUG = adjacent_view<_View, _Np>;
89
90	template <bool _Const>
91	using __inner_iterator _LIBCPP_NODEBUG = iterator_t<__maybe_const<_Const, _InnerView>>;
92
93	template <bool _Const>
94	using __inner_sentinel _LIBCPP_NODEBUG = sentinel_t<__maybe_const<_Const, _InnerView>>;
95
96	template <bool>
97	class __iterator;
98
99	template <bool>
100	class __sentinel;
101
102	public:
103	_LIBCPP_HIDE_FROM_ABI adjacent_transform_view() = default;
104
105	_LIBCPP_HIDE_FROM_ABI constexpr explicit adjacent_transform_view(_View __base, _Fn __fun)
106	: __inner_(std::move(__base)), __fun_(std::in_place, std::move(__fun)) {}
107
108	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
109	requires copy_constructible<_View>
110	{
111	return __inner_.base();
112	}
113	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__inner_).base(); }
114
115	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() { return __iterator<false>(*this, __inner_.begin()); }
116
117	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
118	requires range<const _InnerView> && regular_invocable<__apply_n<const _Fn&, _Np>, range_reference_t<const _View>>
119	{
120	return __iterator<true>(*this, __inner_.begin());
121	}
122
123	_LIBCPP_HIDE_FROM_ABI constexpr auto end() {
124	if constexpr (common_range<_InnerView>) {
125	return __iterator<false>(*this, __inner_.end());
126	} else {
127	return __sentinel<false>(__inner_.end());
128	}
129	}
130
131	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const
132	requires range<const _InnerView> && regular_invocable<__apply_n<const _Fn&, _Np>, range_reference_t<const _View>>
133	{
134	if constexpr (common_range<const _InnerView>) {
135	return __iterator<true>(*this, __inner_.end());
136	} else {
137	return __sentinel<true>(__inner_.end());
138	}
139	}
140
141	_LIBCPP_HIDE_FROM_ABI constexpr auto size()
142	requires sized_range<_InnerView>
143	{
144	return __inner_.size();
145	}
146
147	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const
148	requires sized_range<const _InnerView>
149	{
150	return __inner_.size();
151	}
152	};
153
154	template <forward_range _View, move_constructible _Fn, size_t _Np>
155	requires view<_View> && (_Np > 0) && is_object_v<_Fn> &&
156	regular_invocable<__apply_n<_Fn&, _Np>, range_reference_t<_View>> &&
157	__referenceable<invoke_result_t<__apply_n<_Fn&, _Np>, range_reference_t<_View>>>
158	template <bool _Const>
159	class adjacent_transform_view<_View, _Fn, _Np>::__iterator {
160	friend adjacent_transform_view;
161
162	using _Parent _LIBCPP_NODEBUG = __maybe_const<_Const, adjacent_transform_view>;
163	using _Base _LIBCPP_NODEBUG = __maybe_const<_Const, _View>;
164
165	_Parent* __parent_ = nullptr;
166	__inner_iterator<_Const> __inner_;
167
168	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, __inner_iterator<_Const> __inner)
169	: __parent_(std::addressof(__parent)), __inner_(std::move(__inner)) {}
170
171	static consteval auto __get_iterator_category() {
172	using _Cat = iterator_traits<iterator_t<_Base>>::iterator_category;
173	if constexpr (!is_reference_v<
174	invoke_result_t<__apply_n<__maybe_const<_Const, _Fn>&, _Np>, range_reference_t<_Base>>>)
175	return input_iterator_tag{};
176	else if constexpr (derived_from<_Cat, random_access_iterator_tag>)
177	return random_access_iterator_tag{};
178	else if constexpr (derived_from<_Cat, bidirectional_iterator_tag>)
179	return bidirectional_iterator_tag{};
180	else if constexpr (derived_from<_Cat, forward_iterator_tag>)
181	return forward_iterator_tag{};
182	else
183	return input_iterator_tag{};
184	}
185
186	template <size_t... _Is>
187	static consteval bool __noexcept_dereference(index_sequence<_Is...>) {
188	return noexcept(std::invoke(
189	std::declval<__maybe_const<_Const, _Fn>&>(), ((void)_Is, *std::declval<iterator_t<_Base> const&>())...));
190	}
191
192	public:
193	using iterator_category = decltype(__get_iterator_category());
194	using iterator_concept = typename __inner_iterator<_Const>::iterator_concept;
195	using value_type =
196	remove_cvref_t<invoke_result_t<__apply_n<__maybe_const<_Const, _Fn>&, _Np>, range_reference_t<_Base>>>;
197	using difference_type = range_difference_t<_Base>;
198
199	_LIBCPP_HIDE_FROM_ABI __iterator() = default;
200
201	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
202	requires _Const && convertible_to<__inner_iterator<false>, __inner_iterator<true>>
203	: __parent_(__i.__parent_), __inner_(std::move(__i.__inner_)) {}
204
205	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const
206	noexcept(__noexcept_dereference(make_index_sequence<_Np>{})) {
207	return std::apply(
208	[&](const auto&... __iters) -> decltype(auto) { return std::invoke(__parent_->__fun_, __iters...); },
209	__adjacent_view_iter_access::__get_current(__inner_));
210	}
211
212	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
213	++__inner_;
214	return *this;
215	}
216
217	_LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
218	auto __tmp = *this;
219	++*this;
220	return __tmp;
221	}
222
223	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
224	requires bidirectional_range<_Base>
225	{
226	--__inner_;
227	return *this;
228	}
229
230	_LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
231	requires bidirectional_range<_Base>
232	{
233	auto __tmp = *this;
234	--*this;
235	return __tmp;
236	}
237
238	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)
239	requires random_access_range<_Base>
240	{
241	__inner_ += __x;
242	return *this;
243	}
244
245	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)
246	requires random_access_range<_Base>
247	{
248	__inner_ -= __x;
249	return *this;
250	}
251
252	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
253	requires random_access_range<_Base>
254	{
255	return std::apply(
256	[&](const auto&... __iters) -> decltype(auto) { return std::invoke(*__parent_->__fun_, __iters[__n]...); },
257	__adjacent_view_iter_access::__get_current(__inner_));
258	}
259
260	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
261	return __x.__inner_ == __y.__inner_;
262	}
263
264	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
265	requires random_access_range<_Base>
266	{
267	return __x.__inner_ < __y.__inner_;
268	}
269
270	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
271	requires random_access_range<_Base>
272	{
273	return __x.__inner_ > __y.__inner_;
274	}
275
276	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
277	requires random_access_range<_Base>
278	{
279	return __x.__inner_ <= __y.__inner_;
280	}
281
282	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
283	requires random_access_range<_Base>
284	{
285	return __x.__inner_ >= __y.__inner_;
286	}
287
288	_LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
289	requires random_access_range<_Base> && three_way_comparable<__inner_iterator<_Const>>
290	{
291	return __x.__inner_ <=> __y.__inner_;
292	}
293
294	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
295	requires random_access_range<_Base>
296	{
297	return __iterator(*__i.__parent_, __i.__inner_ + __n);
298	}
299
300	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
301	requires random_access_range<_Base>
302	{
303	return __iterator(*__i.__parent_, __i.__inner_ + __n);
304	}
305
306	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
307	requires random_access_range<_Base>
308	{
309	return __iterator(*__i.__parent_, __i.__inner_ - __n);
310	}
311
312	_LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
313	requires sized_sentinel_for<__inner_iterator<_Const>, __inner_iterator<_Const>>
314	{
315	return __x.__inner_ - __y.__inner_;
316	}
317	};
318
319	template <forward_range _View, move_constructible _Fn, size_t _Np>
320	requires view<_View> && (_Np > 0) && is_object_v<_Fn> &&
321	regular_invocable<__apply_n<_Fn&, _Np>, range_reference_t<_View>> &&
322	__referenceable<invoke_result_t<__apply_n<_Fn&, _Np>, range_reference_t<_View>>>
323	template <bool _Const>
324	class adjacent_transform_view<_View, _Fn, _Np>::__sentinel {
325	friend adjacent_transform_view;
326
327	__inner_sentinel<_Const> __inner_;
328
329	_LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(__inner_sentinel<_Const> __inner)
330	: __inner_(std::move(__inner)) {}
331
332	public:
333	_LIBCPP_HIDE_FROM_ABI __sentinel() = default;
334
335	_LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
336	requires _Const && convertible_to<__inner_sentinel<false>, __inner_sentinel<_Const>>
337	: __inner_(std::move(__i.__inner_)) {}
338
339	template <bool _OtherConst>
340	requires sentinel_for<__inner_sentinel<_Const>, __inner_iterator<_OtherConst>>
341	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
342	return __x.__inner_ == __y.__inner_;
343	}
344
345	template <bool _OtherConst>
346	requires sized_sentinel_for<__inner_sentinel<_Const>, __inner_iterator<_OtherConst>>
347	_LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _InnerView>>
348	operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
349	return __x.__inner_ - __y.__inner_;
350	}
351
352	template <bool _OtherConst>
353	requires sized_sentinel_for<__inner_sentinel<_Const>, __inner_iterator<_OtherConst>>
354	_LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _InnerView>>
355	operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
356	return __x.__inner_ - __y.__inner_;
357	}
358	};
359
360	namespace views {
361	namespace __adjacent_transform {
362
363	template <size_t _Np>
364	struct __fn : __range_adaptor_closure<__fn<_Np>> {
365	template <class _Range, class _Fn>
366	requires(_Np == 0 && forward_range<_Range &&>)
367	_LIBCPP_HIDE_FROM_ABI static constexpr auto
368	operator()(_Range&&, _Fn&& __fn) noexcept(noexcept(views::zip_transform(std::forward<_Fn>(__fn))))
369	-> decltype(views::zip_transform(std::forward<_Fn>(__fn))) {
370	return views::zip_transform(std::forward<_Fn>(__fn));
371	}
372
373	template <class _Range, class _Fn>
374	_LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&& __range, _Fn&& __fn) noexcept(
375	noexcept(adjacent_transform_view<views::all_t<_Range&&>, decay_t<_Fn>, _Np>(
376	std::forward<_Range>(__range), std::forward<_Fn>(__fn))))
377	-> decltype(adjacent_transform_view<views::all_t<_Range&&>, decay_t<_Fn>, _Np>(
378	std::forward<_Range>(__range), std::forward<_Fn>(__fn))) {
379	return adjacent_transform_view<views::all_t<_Range&&>, decay_t<_Fn>, _Np>(
380	std::forward<_Range>(__range), std::forward<_Fn>(__fn));
381	}
382
383	template <class _Fn>
384	requires constructible_from<decay_t<_Fn>, _Fn>
385	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __f) const
386	noexcept(is_nothrow_constructible_v<decay_t<_Fn>, _Fn>) {
387	return __pipeable(std::__bind_back(*this, std::forward<_Fn>(__f)));
388	}
389	};
390
391	} // namespace __adjacent_transform
392	inline namespace __cpo {
393	template <size_t _Np>
394	inline constexpr auto adjacent_transform = __adjacent_transform::__fn<_Np>{};
395	inline constexpr auto pairwise_transform = adjacent_transform<2>;
396	} // namespace __cpo
397	} // namespace views
398	} // namespace ranges
399
400	#endif // _LIBCPP_STD_VER >= 23
401
402	_LIBCPP_END_NAMESPACE_STD
403
404	_LIBCPP_POP_MACROS
405
406	#endif // _LIBCPP___RANGES_ADJACENT_TRANSFORM_VIEW_H

lib/libcxx/include/__ranges/adjacent_view.h created+419

...	@@ -0,0 +1,419 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___RANGES_ADJACENT_VIEW_H
11	#define _LIBCPP___RANGES_ADJACENT_VIEW_H
12
13	#include <__config>
14
15	#include <__algorithm/min.h>
16	#include <__compare/three_way_comparable.h>
17	#include <__concepts/constructible.h>
18	#include <__concepts/convertible_to.h>
19	#include <__concepts/equality_comparable.h>
20	#include <__cstddef/size_t.h>
21	#include <__functional/invoke.h>
22	#include <__functional/operations.h>
23	#include <__iterator/concepts.h>
24	#include <__iterator/incrementable_traits.h>
25	#include <__iterator/iter_move.h>
26	#include <__iterator/iter_swap.h>
27	#include <__iterator/iterator_traits.h>
28	#include <__iterator/next.h>
29	#include <__iterator/prev.h>
30	#include <__ranges/access.h>
31	#include <__ranges/all.h>
32	#include <__ranges/concepts.h>
33	#include <__ranges/empty_view.h>
34	#include <__ranges/enable_borrowed_range.h>
35	#include <__ranges/range_adaptor.h>
36	#include <__ranges/size.h>
37	#include <__ranges/view_interface.h>
38	#include <__tuple/tuple_transform.h>
39	#include <__type_traits/common_type.h>
40	#include <__type_traits/is_nothrow_constructible.h>
41	#include <__type_traits/make_unsigned.h>
42	#include <__type_traits/maybe_const.h>
43	#include <__utility/declval.h>
44	#include <__utility/forward.h>
45	#include <__utility/integer_sequence.h>
46	#include <__utility/move.h>
47	#include <array>
48	#include <tuple>
49
50	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
51	# pragma GCC system_header
52	#endif
53
54	_LIBCPP_PUSH_MACROS
55	#include <__undef_macros>
56
57	_LIBCPP_BEGIN_NAMESPACE_STD
58
59	#if _LIBCPP_STD_VER >= 23
60
61	namespace ranges {
62
63	template <forward_range _View, size_t _Np>
64	requires view<_View> && (_Np > 0)
65	class adjacent_view : public view_interface<adjacent_view<_View, _Np>> {
66	private:
67	_LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();
68
69	template <bool>
70	class __iterator;
71
72	template <bool>
73	class __sentinel;
74
75	struct __as_sentinel {};
76
77	public:
78	_LIBCPP_HIDE_FROM_ABI adjacent_view()
79	requires default_initializable<_View>
80	= default;
81
82	_LIBCPP_HIDE_FROM_ABI constexpr explicit adjacent_view(_View __base) : __base_(std::move(__base)) {}
83
84	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
85	requires copy_constructible<_View>
86	{
87	return __base_;
88	}
89	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
90
91	_LIBCPP_HIDE_FROM_ABI constexpr auto begin()
92	requires(!__simple_view<_View>)
93	{
94	return __iterator<false>(ranges::begin(__base_), ranges::end(__base_));
95	}
96
97	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
98	requires range<const _View> // LWG4482 This is under-constrained.
99	{
100	return __iterator<true>(ranges::begin(__base_), ranges::end(__base_));
101	}
102
103	_LIBCPP_HIDE_FROM_ABI constexpr auto end()
104	requires(!__simple_view<_View>)
105	{
106	if constexpr (common_range<_View>) {
107	return __iterator<false>(__as_sentinel{}, ranges::begin(__base_), ranges::end(__base_));
108	} else {
109	return __sentinel<false>(ranges::end(__base_));
110	}
111	}
112
113	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const
114	requires range<const _View> // LWG4482 This is under-constrained.
115	{
116	if constexpr (common_range<const _View>) {
117	return __iterator<true>(__as_sentinel{}, ranges::begin(__base_), ranges::end(__base_));
118	} else {
119	return __sentinel<true>(ranges::end(__base_));
120	}
121	}
122
123	_LIBCPP_HIDE_FROM_ABI constexpr auto size()
124	requires sized_range<_View>
125	{
126	using _ST = decltype(ranges::size(__base_));
127	using _CT = common_type_t<_ST, size_t>;
128	auto __sz = static_cast<_CT>(ranges::size(__base_));
129	__sz -= std::min<_CT>(__sz, _Np - 1);
130	return static_cast<_ST>(__sz);
131	}
132
133	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const
134	requires sized_range<const _View>
135	{
136	using _ST = decltype(ranges::size(__base_));
137	using _CT = common_type_t<_ST, size_t>;
138	auto __sz = static_cast<_CT>(ranges::size(__base_));
139	__sz -= std::min<_CT>(__sz, _Np - 1);
140	return static_cast<_ST>(__sz);
141	}
142	};
143
144	struct __adjacent_view_iter_access {
145	template <class _Iter>
146	_LIBCPP_HIDE_FROM_ABI constexpr static auto& __get_current(_Iter& __it) noexcept {
147	return __it.__current_;
148	}
149	};
150
151	template <forward_range _View, size_t _Np>
152	requires view<_View> && (_Np > 0)
153	template <bool _Const>
154	class adjacent_view<_View, _Np>::__iterator {
155	friend __adjacent_view_iter_access;
156	friend adjacent_view;
157	using _Base _LIBCPP_NODEBUG = __maybe_const<_Const, _View>;
158	array<iterator_t<_Base>, _Np> __current_ = array<iterator_t<_Base>, _Np>();
159
160	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(iterator_t<_Base> __first, sentinel_t<_Base> __last) {
161	__current_[0] = __first;
162	for (size_t __i = 1; __i < _Np; ++__i) {
163	__current_[__i] = ranges::next(__current_[__i - 1], 1, __last);
164	}
165	}
166
167	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(__as_sentinel, iterator_t<_Base> __first, iterator_t<_Base> __last) {
168	if constexpr (!bidirectional_range<_Base>) {
169	__current_.fill(__last);
170	} else {
171	__current_[_Np - 1] = __last;
172	for (int __i = static_cast<int>(_Np) - 2; __i >= 0; --__i) {
173	__current_[__i] = ranges::prev(__current_[__i + 1], 1, __first);
174	}
175	}
176	}
177
178	template <class _Iter, size_t... _Is>
179	_LIBCPP_HIDE_FROM_ABI explicit constexpr __iterator(_Iter&& __i, index_sequence<_Is...>)
180	: __current_{std::move(__i.__current_[_Is])...} {}
181
182	static consteval auto __get_iterator_concept() {
183	if constexpr (random_access_range<_Base>)
184	return random_access_iterator_tag{};
185	else if constexpr (bidirectional_range<_Base>)
186	return bidirectional_iterator_tag{};
187	else
188	return forward_iterator_tag{};
189	}
190
191	template <class _Tp, size_t _Index>
192	using __always _LIBCPP_NODEBUG = _Tp;
193
194	template <class _Tp, size_t... _Is>
195	static auto __repeat_tuple_helper(index_sequence<_Is...>) -> tuple<__always<_Tp, _Is>...>;
196
197	public:
198	using iterator_category = input_iterator_tag;
199	using iterator_concept = decltype(__get_iterator_concept());
200	using value_type = decltype(__repeat_tuple_helper<range_value_t<_Base>>(make_index_sequence<_Np>{}));
201	using difference_type = range_difference_t<_Base>;
202
203	_LIBCPP_HIDE_FROM_ABI __iterator() = default;
204	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
205	requires _Const && convertible_to<iterator_t<_View>, iterator_t<const _View>>
206	: __iterator(std::move(__i), make_index_sequence<_Np>{}) {}
207
208	_LIBCPP_HIDE_FROM_ABI constexpr auto operator*() const {
209	return std::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
210	}
211
212	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
213	for (auto& __i : __current_) {
214	++__i;
215	}
216	return *this;
217	}
218
219	_LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int) {
220	auto __tmp = *this;
221	++*this;
222	return __tmp;
223	}
224
225	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
226	requires bidirectional_range<_Base>
227	{
228	for (auto& __i : __current_) {
229	--__i;
230	}
231	return *this;
232	}
233
234	_LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
235	requires bidirectional_range<_Base>
236	{
237	auto __tmp = *this;
238	--*this;
239	return __tmp;
240	}
241
242	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)
243	requires random_access_range<_Base>
244	{
245	for (auto& __i : __current_) {
246	__i += __x;
247	}
248	return *this;
249	}
250
251	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)
252	requires random_access_range<_Base>
253	{
254	for (auto& __i : __current_) {
255	__i -= __x;
256	}
257	return *this;
258	}
259
260	_LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const
261	requires random_access_range<_Base>
262	{
263	return std::__tuple_transform([&](auto& __i) -> decltype(auto) { return __i[__n]; }, __current_);
264	}
265
266	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
267	return __x.__current_.back() == __y.__current_.back();
268	}
269
270	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<(const __iterator& __x, const __iterator& __y)
271	requires random_access_range<_Base>
272	{
273	return __x.__current_.back() < __y.__current_.back();
274	}
275
276	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>(const __iterator& __x, const __iterator& __y)
277	requires random_access_range<_Base>
278	{
279	return __y < __x;
280	}
281
282	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator<=(const __iterator& __x, const __iterator& __y)
283	requires random_access_range<_Base>
284	{
285	return !(__y < __x);
286	}
287
288	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator>=(const __iterator& __x, const __iterator& __y)
289	requires random_access_range<_Base>
290	{
291	return !(__x < __y);
292	}
293
294	_LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
295	requires random_access_range<_Base> && three_way_comparable<iterator_t<_Base>>
296	{
297	return __x.__current_.back() <=> __y.__current_.back();
298	}
299
300	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
301	requires random_access_range<_Base>
302	{
303	auto __r = __i;
304	__r += __n;
305	return __r;
306	}
307
308	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
309	requires random_access_range<_Base>
310	{
311	return __i + __n;
312	}
313
314	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
315	requires random_access_range<_Base>
316	{
317	auto __r = __i;
318	__r -= __n;
319	return __r;
320	}
321
322	_LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
323	requires sized_sentinel_for<iterator_t<_Base>, iterator_t<_Base>>
324	{
325	return __x.__current_.back() - __y.__current_.back();
326	}
327
328	_LIBCPP_HIDE_FROM_ABI friend constexpr auto iter_move(const __iterator& __i) noexcept(
329	noexcept(ranges::iter_move(std::declval<const iterator_t<_Base>&>())) &&
330	is_nothrow_move_constructible_v<range_rvalue_reference_t<_Base>>) {
331	return std::__tuple_transform(ranges::iter_move, __i.__current_);
332	}
333
334	_LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(
335	noexcept(ranges::iter_swap(std::declval<iterator_t<_Base>>(), std::declval<iterator_t<_Base>>())))
336	requires indirectly_swappable<iterator_t<_Base>>
337	{
338	for (size_t __i = 0; __i < _Np; ++__i) {
339	ranges::iter_swap(__l.__current_[__i], __r.__current_[__i]);
340	}
341	}
342	};
343
344	template <forward_range _View, size_t _Np>
345	requires view<_View> && (_Np > 0)
346	template <bool _Const>
347	class adjacent_view<_View, _Np>::__sentinel {
348	friend adjacent_view;
349	using _Base _LIBCPP_NODEBUG = __maybe_const<_Const, _View>;
350	sentinel_t<_Base> __end_ = sentinel_t<_Base>();
351
352	_LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(sentinel_t<_Base> __end) { __end_ = std::move(__end); }
353
354	public:
355	_LIBCPP_HIDE_FROM_ABI __sentinel() = default;
356
357	_LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
358	requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
359	: __end_(std::move(__i.__end_)) {}
360
361	template <bool _OtherConst>
362	requires sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
363	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
364	return __x.__current_.back() == __y.__end_;
365	}
366
367	template <bool _OtherConst>
368	requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
369	_LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
370	operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
371	return __x.__current_.back() - __y.__end_;
372	}
373
374	template <bool _OtherConst>
375	requires sized_sentinel_for<sentinel_t<_Base>, iterator_t<__maybe_const<_OtherConst, _View>>>
376	_LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _View>>
377	operator-(const __sentinel& __y, const __iterator<_OtherConst>& __x) {
378	return __y.__end_ - __x.__current_.back();
379	}
380	};
381
382	template <class _View, size_t _Np>
383	constexpr bool enable_borrowed_range<adjacent_view<_View, _Np>> = enable_borrowed_range<_View>;
384
385	namespace views {
386	namespace __adjacent {
387
388	template <size_t _Np>
389	struct __fn : __range_adaptor_closure<__fn<_Np>> {
390	template <class _Range>
391	requires(_Np == 0 && forward_range<_Range &&>)
392	_LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Range&&) noexcept {
393	return empty_view<tuple<>>{};
394	}
395
396	template <class _Ranges>
397	_LIBCPP_HIDE_FROM_ABI static constexpr auto operator()(_Ranges&& __range) noexcept(
398	noexcept(adjacent_view<views::all_t<_Ranges&&>, _Np>(std::forward<_Ranges>(__range))))
399	-> decltype(adjacent_view<views::all_t<_Ranges&&>, _Np>(std::forward<_Ranges>(__range))) {
400	return adjacent_view<views::all_t<_Ranges&&>, _Np>(std::forward<_Ranges>(__range));
401	}
402	};
403
404	} // namespace __adjacent
405	inline namespace __cpo {
406	template <size_t _Np>
407	inline constexpr auto adjacent = __adjacent::__fn<_Np>{};
408	inline constexpr auto pairwise = adjacent<2>;
409	} // namespace __cpo
410	} // namespace views
411	} // namespace ranges
412
413	#endif // _LIBCPP_STD_VER >= 23
414
415	_LIBCPP_END_NAMESPACE_STD
416
417	_LIBCPP_POP_MACROS
418
419	#endif // _LIBCPP___RANGES_ADJACENT_VIEW_H

lib/libcxx/include/__ranges/as_rvalue_view.h+9-9

lib/libcxx/include/__ranges/chunk_by_view.h+6-6

lib/libcxx/include/__ranges/common_view.h+7-7

lib/libcxx/include/__ranges/drop_view.h+8-8

lib/libcxx/include/__ranges/drop_while_view.h+5-5

lib/libcxx/include/__ranges/elements_of.h created+49

...	@@ -0,0 +1,49 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___RANGES_ELEMENTS_OF_H
11	#define _LIBCPP___RANGES_ELEMENTS_OF_H
12
13	#include <__config>
14	#include <__cstddef/byte.h>
15	#include <__memory/allocator.h>
16	#include <__ranges/concepts.h>
17	#include <__utility/forward.h>
18
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header
21	#endif
22
23	_LIBCPP_PUSH_MACROS
24	#include <__undef_macros>
25
26	_LIBCPP_BEGIN_NAMESPACE_STD
27
28	#if _LIBCPP_STD_VER >= 23
29
30	namespace ranges {
31
32	template <range _Range, class _Allocator = allocator<byte>>
33	struct elements_of {
34	_LIBCPP_NO_UNIQUE_ADDRESS _Range range;
35	_LIBCPP_NO_UNIQUE_ADDRESS _Allocator allocator = _Allocator();
36	};
37
38	template <class _Range, class _Allocator = allocator<byte>>
39	elements_of(_Range&&, _Allocator = _Allocator()) -> elements_of<_Range&&, _Allocator>;
40
41	} // namespace ranges
42
43	#endif // _LIBCPP_STD_VER >= 23
44
45	_LIBCPP_END_NAMESPACE_STD
46
47	_LIBCPP_POP_MACROS
48
49	#endif // _LIBCPP___RANGES_ELEMENTS_OF_H

lib/libcxx/include/__ranges/empty_view.h+5-5

...	@@ -29,11 +29,11 @@ template <class _Tp>	...	@@ -29,11 +29,11 @@ template <class _Tp>
29	requires is_object_v<_Tp>	29	requires is_object_v<_Tp>
30	class empty_view : public view_interface<empty_view<_Tp>> {	30	class empty_view : public view_interface<empty_view<_Tp>> {
31	public:	31	public:
32	_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }	32	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* begin() noexcept { return nullptr; }
33	_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }	33	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* end() noexcept { return nullptr; }
34	_LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }	34	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr _Tp* data() noexcept { return nullptr; }
35	_LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }	35	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 0; }
36	_LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }	36	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return true; }
37	};	37	};
38		38
39	template <class _Tp>	39	template <class _Tp>

lib/libcxx/include/__ranges/filter_view.h+10-10

lib/libcxx/include/__ranges/iota_view.h+41-22

...	@@ -30,6 +30,7 @@	...	@@ -30,6 +30,7 @@
30	#include <__ranges/movable_box.h>	30	#include <__ranges/movable_box.h>
31	#include <__ranges/view_interface.h>	31	#include <__ranges/view_interface.h>
32	#include <__type_traits/conditional.h>	32	#include <__type_traits/conditional.h>
		33	#include <__type_traits/decay.h>
33	#include <__type_traits/is_nothrow_constructible.h>	34	#include <__type_traits/is_nothrow_constructible.h>
34	#include <__type_traits/make_unsigned.h>	35	#include <__type_traits/make_unsigned.h>
35	#include <__type_traits/type_identity.h>	36	#include <__type_traits/type_identity.h>
...	@@ -57,11 +58,17 @@ struct __get_wider_signed {	...	@@ -57,11 +58,17 @@ struct __get_wider_signed {
57	return type_identity<int>{};	58	return type_identity<int>{};
58	else if constexpr (sizeof(_Int) < sizeof(long))	59	else if constexpr (sizeof(_Int) < sizeof(long))
59	return type_identity<long>{};	60	return type_identity<long>{};
60	else	61	else if constexpr (sizeof(_Int) < sizeof(long long))
61	return type_identity<long long>{};	62	return type_identity<long long>{};
62		63	# if _LIBCPP_HAS_INT128
63	static_assert(	64	else if constexpr (sizeof(_Int) <= sizeof(__int128))
64	sizeof(_Int) <= sizeof(long long), "Found integer-like type that is bigger than largest integer like type.");	65	return type_identity<__int128>{};
		66	# else
		67	else if constexpr (sizeof(_Int) <= sizeof(long long))
		68	return type_identity<long long>{};
		69	# endif
		70	else
		71	static_assert(false, "Found integer-like type that is bigger than the largest integer like type.");
65	}	72	}
66		73
67	using type = typename decltype(__call())::type;	74	using type = typename decltype(__call())::type;
...	@@ -125,7 +132,8 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {	...	@@ -125,7 +132,8 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
125		132
126	_LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}	133	_LIBCPP_HIDE_FROM_ABI constexpr explicit __iterator(_Start __value) : __value_(std::move(__value)) {}
127		134
128	_LIBCPP_HIDE_FROM_ABI constexpr _Start operator*() const noexcept(is_nothrow_copy_constructible_v<_Start>) {	135	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Start operator*() const
		136	noexcept(is_nothrow_copy_constructible_v<_Start>) {
129	return __value_;	137	return __value_;
130	}	138	}
131		139
...	@@ -189,7 +197,7 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {	...	@@ -189,7 +197,7 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
189	return *this;	197	return *this;
190	}	198	}
191		199
192	_LIBCPP_HIDE_FROM_ABI constexpr _Start operator[](difference_type __n) const	200	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Start operator[](difference_type __n) const
193	requires __advanceable<_Start>	201	requires __advanceable<_Start>
194	{	202	{
195	return _Start(__value_ + __n);	203	return _Start(__value_ + __n);
...	@@ -231,27 +239,28 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {	...	@@ -231,27 +239,28 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
231	return __x.__value_ <=> __y.__value_;	239	return __x.__value_ <=> __y.__value_;
232	}	240	}
233		241
234	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n)	242	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n)
235	requires __advanceable<_Start>	243	requires __advanceable<_Start>
236	{	244	{
237	__i += __n;	245	__i += __n;
238	return __i;	246	return __i;
239	}	247	}
240		248
241	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i)	249	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i)
242	requires __advanceable<_Start>	250	requires __advanceable<_Start>
243	{	251	{
244	return __i + __n;	252	return __i + __n;
245	}	253	}
246		254
247	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n)	255	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n)
248	requires __advanceable<_Start>	256	requires __advanceable<_Start>
249	{	257	{
250	__i -= __n;	258	__i -= __n;
251	return __i;	259	return __i;
252	}	260	}
253		261
254	_LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)	262	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
		263	operator-(const __iterator& __x, const __iterator& __y)
255	requires __advanceable<_Start>	264	requires __advanceable<_Start>
256	{	265	{
257	if constexpr (__integer_like<_Start>) {	266	if constexpr (__integer_like<_Start>) {
...	@@ -282,14 +291,14 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {	...	@@ -282,14 +291,14 @@ class iota_view : public view_interface<iota_view<_Start, _BoundSentinel>> {
282	return __x.__value_ == __y.__bound_sentinel_;	291	return __x.__value_ == __y.__bound_sentinel_;
283	}	292	}
284		293
285	_LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>	294	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>
286	operator-(const __iterator& __x, const __sentinel& __y)	295	operator-(const __iterator& __x, const __sentinel& __y)
287	requires sized_sentinel_for<_BoundSentinel, _Start>	296	requires sized_sentinel_for<_BoundSentinel, _Start>
288	{	297	{
289	return __x.__value_ - __y.__bound_sentinel_;	298	return __x.__value_ - __y.__bound_sentinel_;
290	}	299	}
291		300
292	_LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>	301	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr iter_difference_t<_Start>
293	operator-(const __sentinel& __x, const __iterator& __y)	302	operator-(const __sentinel& __x, const __iterator& __y)
294	requires sized_sentinel_for<_BoundSentinel, _Start>	303	requires sized_sentinel_for<_BoundSentinel, _Start>
295	{	304	{
...	@@ -329,24 +338,24 @@ public:	...	@@ -329,24 +338,24 @@ public:
329	requires(!same_as<_Start, _BoundSentinel> && !same_as<_BoundSentinel, unreachable_sentinel_t>)	338	requires(!same_as<_Start, _BoundSentinel> && !same_as<_BoundSentinel, unreachable_sentinel_t>)
330	: iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}	339	: iota_view(std::move(__first.__value_), std::move(__last.__bound_sentinel_)) {}
331		340
332	_LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator{__value_}; }	341	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator{__value_}; }
333		342
334	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const {	343	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const {
335	if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)	344	if constexpr (same_as<_BoundSentinel, unreachable_sentinel_t>)
336	return unreachable_sentinel;	345	return unreachable_sentinel;
337	else	346	else
338	return __sentinel{__bound_sentinel_};	347	return __sentinel{__bound_sentinel_};
339	}	348	}
340		349
341	_LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const	350	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
342	requires same_as<_Start, _BoundSentinel>	351	requires same_as<_Start, _BoundSentinel>
343	{	352	{
344	return __iterator{__bound_sentinel_};	353	return __iterator{__bound_sentinel_};
345	}	354	}
346		355
347	_LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return __value_ == __bound_sentinel_; }	356	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const { return __value_ == __bound_sentinel_; }
348		357
349	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	358	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
350	requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) \|\|	359	requires(same_as<_Start, _BoundSentinel> && __advanceable<_Start>) \|\|
351	(integral<_Start> && integral<_BoundSentinel>) \|\| sized_sentinel_for<_BoundSentinel, _Start>	360	(integral<_Start> && integral<_BoundSentinel>) \|\| sized_sentinel_for<_BoundSentinel, _Start>
352	{	361	{
...	@@ -374,14 +383,15 @@ namespace views {	...	@@ -374,14 +383,15 @@ namespace views {
374	namespace __iota {	383	namespace __iota {
375	struct __fn {	384	struct __fn {
376	template <class _Start>	385	template <class _Start>
377	_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start) const	386	requires(requires(_Start __s) { ranges::iota_view<decay_t<_Start>>(std::forward<_Start>(__s)); })
378	noexcept(noexcept(ranges::iota_view(std::forward<_Start>(__start))))	387	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start) const
379	-> decltype(ranges::iota_view(std::forward<_Start>(__start))) {	388	noexcept(noexcept(ranges::iota_view<decay_t<_Start>>(std::forward<_Start>(__start)))) {
380	return ranges::iota_view(std::forward<_Start>(__start));	389	return ranges::iota_view<decay_t<_Start>>(std::forward<_Start>(__start));
381	}	390	}
382		391
383	template <class _Start, class _BoundSentinel>	392	template <class _Start, class _BoundSentinel>
384	_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const noexcept(	393	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto
		394	operator()(_Start&& __start, _BoundSentinel&& __bound_sentinel) const noexcept(
385	noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))	395	noexcept(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))))
386	-> decltype(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))) {	396	-> decltype(ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel))) {
387	return ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel));	397	return ranges::iota_view(std::forward<_Start>(__start), std::forward<_BoundSentinel>(__bound_sentinel));
...	@@ -392,6 +402,15 @@ struct __fn {	...	@@ -392,6 +402,15 @@ struct __fn {
392	inline namespace __cpo {	402	inline namespace __cpo {
393	inline constexpr auto iota = __iota::__fn{};	403	inline constexpr auto iota = __iota::__fn{};
394	} // namespace __cpo	404	} // namespace __cpo
		405
		406	# if _LIBCPP_STD_VER >= 26
		407
		408	inline constexpr auto indices = [] [[nodiscard]] (__integer_like auto __size) static {
		409	return ranges::views::iota(decltype(__size){}, __size);
		410	};
		411
		412	# endif
		413
395	} // namespace views	414	} // namespace views
396	} // namespace ranges	415	} // namespace ranges
397		416

lib/libcxx/include/__ranges/owning_view.h+15-15

lib/libcxx/include/__ranges/ref_view.h+6-6

lib/libcxx/include/__ranges/repeat_view.h+17-10

 @@ -108,17 +108,21 @@ public:
           __bound_ >= 0, "The behavior is undefined if Bound is not unreachable_sentinel_t and bound is negative");
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const { return __iterator(std::addressof(*__value_)); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() const {
+    return __iterator(std::addressof(*__value_));
+  }
-  _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator end() const
     requires(!same_as<_Bound, unreachable_sentinel_t>)
   {
     return __iterator(std::addressof(*__value_), __bound_);
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr unreachable_sentinel_t end() const noexcept { return unreachable_sentinel; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr unreachable_sentinel_t end() const noexcept {
+    return unreachable_sentinel;
+  }
-  _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
     requires(!same_as<_Bound, unreachable_sentinel_t>)
   {
     return std::__to_unsigned_like(__bound_);
 @@ -152,7 +156,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI __iterator() = default;
-  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const noexcept { return *__value_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const noexcept { return *__value_; }
   _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
     ++__current_;
 @@ -192,7 +196,9 @@ public:
     return *this;
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](difference_type __n) const noexcept { return *(*this + __n); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator[](difference_type __n) const noexcept {
+    return *(*this + __n);
+  }
   _LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y) {
     return __x.__current_ == __y.__current_;
 @@ -202,22 +208,23 @@ public:
     return __x.__current_ <=> __y.__current_;
   }
-  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(__iterator __i, difference_type __n) {
     __i += __n;
     return __i;
   }
-  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, __iterator __i) {
     __i += __n;
     return __i;
   }
-  _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(__iterator __i, difference_type __n) {
     __i -= __n;
     return __i;
   }
-  _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr difference_type
+  operator-(const __iterator& __x, const __iterator& __y) {
     return static_cast<difference_type>(__x.__current_) - static_cast<difference_type>(__y.__current_);
   }

lib/libcxx/include/__ranges/single_view.h+8-8

...	@@ -63,21 +63,21 @@ public:	...	@@ -63,21 +63,21 @@ public:
63	_LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(in_place_t, _Args&&... __args)	63	_LIBCPP_HIDE_FROM_ABI constexpr explicit single_view(in_place_t, _Args&&... __args)
64	: __value_{in_place, std::forward<_Args>(__args)...} {}	64	: __value_{in_place, std::forward<_Args>(__args)...} {}
65		65
66	_LIBCPP_HIDE_FROM_ABI constexpr _Tp* begin() noexcept { return data(); }	66	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* begin() noexcept { return data(); }
67		67
68	_LIBCPP_HIDE_FROM_ABI constexpr const _Tp* begin() const noexcept { return data(); }	68	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* begin() const noexcept { return data(); }
69		69
70	_LIBCPP_HIDE_FROM_ABI constexpr _Tp* end() noexcept { return data() + 1; }	70	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* end() noexcept { return data() + 1; }
71		71
72	_LIBCPP_HIDE_FROM_ABI constexpr const _Tp* end() const noexcept { return data() + 1; }	72	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* end() const noexcept { return data() + 1; }
73		73
74	_LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return false; }	74	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr bool empty() noexcept { return false; }
75		75
76	_LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 1; }	76	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr size_t size() noexcept { return 1; }
77		77
78	_LIBCPP_HIDE_FROM_ABI constexpr _Tp* data() noexcept { return __value_.operator->(); }	78	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp* data() noexcept { return __value_.operator->(); }
79		79
80	_LIBCPP_HIDE_FROM_ABI constexpr const _Tp* data() const noexcept { return __value_.operator->(); }	80	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp* data() const noexcept { return __value_.operator->(); }
81	};	81	};
82		82
83	template <class _Tp>	83	template <class _Tp>

lib/libcxx/include/__ranges/take_view.h+9-9

lib/libcxx/include/__ranges/transform_view.h+1-2

lib/libcxx/include/__ranges/view_interface.h+10-10

lib/libcxx/include/__ranges/zip_transform_view.h created+357

...	@@ -0,0 +1,357 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___RANGES_ZIP_TRANSFORM_VIEW_H
11	#define _LIBCPP___RANGES_ZIP_TRANSFORM_VIEW_H
12
13	#include <__config>
14
15	#include <__concepts/constructible.h>
16	#include <__concepts/convertible_to.h>
17	#include <__concepts/derived_from.h>
18	#include <__concepts/equality_comparable.h>
19	#include <__concepts/invocable.h>
20	#include <__functional/invoke.h>
21	#include <__iterator/concepts.h>
22	#include <__iterator/incrementable_traits.h>
23	#include <__iterator/iterator_traits.h>
24	#include <__memory/addressof.h>
25	#include <__ranges/access.h>
26	#include <__ranges/all.h>
27	#include <__ranges/concepts.h>
28	#include <__ranges/empty_view.h>
29	#include <__ranges/movable_box.h>
30	#include <__ranges/view_interface.h>
31	#include <__ranges/zip_view.h>
32	#include <__type_traits/decay.h>
33	#include <__type_traits/invoke.h>
34	#include <__type_traits/is_object.h>
35	#include <__type_traits/is_reference.h>
36	#include <__type_traits/is_referenceable.h>
37	#include <__type_traits/maybe_const.h>
38	#include <__type_traits/remove_cvref.h>
39	#include <__utility/forward.h>
40	#include <__utility/in_place.h>
41	#include <__utility/move.h>
42	#include <tuple> // for std::apply
43
44	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
45	# pragma GCC system_header
46	#endif
47
48	_LIBCPP_PUSH_MACROS
49	#include <__undef_macros>
50	_LIBCPP_BEGIN_NAMESPACE_STD
51
52	#if _LIBCPP_STD_VER >= 23
53
54	namespace ranges {
55
56	template <move_constructible _Fn, input_range... _Views>
57	requires(view<_Views> && ...) &&
58	(sizeof...(_Views) > 0) && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_Views>...> &&
59	__referenceable<invoke_result_t<_Fn&, range_reference_t<_Views>...>>
60	class zip_transform_view : public view_interface<zip_transform_view<_Fn, _Views...>> {
61	_LIBCPP_NO_UNIQUE_ADDRESS zip_view<_Views...> __zip_;
62	_LIBCPP_NO_UNIQUE_ADDRESS __movable_box<_Fn> __fun_;
63
64	using _InnerView _LIBCPP_NODEBUG = zip_view<_Views...>;
65	template <bool _Const>
66	using __ziperator _LIBCPP_NODEBUG = iterator_t<__maybe_const<_Const, _InnerView>>;
67	template <bool _Const>
68	using __zentinel _LIBCPP_NODEBUG = sentinel_t<__maybe_const<_Const, _InnerView>>;
69
70	template <bool>
71	class __iterator;
72
73	template <bool>
74	class __sentinel;
75
76	public:
77	_LIBCPP_HIDE_FROM_ABI zip_transform_view() = default;
78
79	_LIBCPP_HIDE_FROM_ABI constexpr explicit zip_transform_view(_Fn __fun, _Views... __views)
80	: __zip_(std::move(__views)...), __fun_(in_place, std::move(__fun)) {}
81
82	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() { return __iterator<false>(*this, __zip_.begin()); }
83
84	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
85	requires range<const _InnerView> && regular_invocable<const _Fn&, range_reference_t<const _Views>...>
86	{
87	return __iterator<true>(*this, __zip_.begin());
88	}
89
90	_LIBCPP_HIDE_FROM_ABI constexpr auto end() {
91	if constexpr (common_range<_InnerView>) {
92	return __iterator<false>(*this, __zip_.end());
93	} else {
94	return __sentinel<false>(__zip_.end());
95	}
96	}
97
98	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const
99	requires range<const _InnerView> && regular_invocable<const _Fn&, range_reference_t<const _Views>...>
100	{
101	if constexpr (common_range<const _InnerView>) {
102	return __iterator<true>(*this, __zip_.end());
103	} else {
104	return __sentinel<true>(__zip_.end());
105	}
106	}
107
108	_LIBCPP_HIDE_FROM_ABI constexpr auto size()
109	requires sized_range<_InnerView>
110	{
111	return __zip_.size();
112	}
113
114	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const
115	requires sized_range<const _InnerView>
116	{
117	return __zip_.size();
118	}
119	};
120
121	template <class _Fn, class... _Ranges>
122	zip_transform_view(_Fn, _Ranges&&...) -> zip_transform_view<_Fn, views::all_t<_Ranges>...>;
123
124	template <bool _Const, class _Fn, class... _Views>
125	struct __zip_transform_iterator_category_base {};
126
127	template <bool _Const, class _Fn, class... _Views>
128	requires forward_range<__maybe_const<_Const, zip_view<_Views...>>>
129	struct __zip_transform_iterator_category_base<_Const, _Fn, _Views...> {
130	private:
131	template <class _View>
132	using __tag _LIBCPP_NODEBUG = typename iterator_traits<iterator_t<__maybe_const<_Const, _View>>>::iterator_category;
133
134	static consteval auto __get_iterator_category() {
135	if constexpr (!is_reference_v<invoke_result_t<__maybe_const<_Const, _Fn>&,
136	range_reference_t<__maybe_const<_Const, _Views>>...>>) {
137	return input_iterator_tag();
138	} else if constexpr ((derived_from<__tag<_Views>, random_access_iterator_tag> && ...)) {
139	return random_access_iterator_tag();
140	} else if constexpr ((derived_from<__tag<_Views>, bidirectional_iterator_tag> && ...)) {
141	return bidirectional_iterator_tag();
142	} else if constexpr ((derived_from<__tag<_Views>, forward_iterator_tag> && ...)) {
143	return forward_iterator_tag();
144	} else {
145	return input_iterator_tag();
146	}
147	}
148
149	public:
150	using iterator_category = decltype(__get_iterator_category());
151	};
152
153	template <move_constructible _Fn, input_range... _Views>
154	requires(view<_Views> && ...) &&
155	(sizeof...(_Views) > 0) && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_Views>...> &&
156	__referenceable<invoke_result_t<_Fn&, range_reference_t<_Views>...>>
157	template <bool _Const>
158	class zip_transform_view<_Fn, _Views...>::__iterator
159	: public __zip_transform_iterator_category_base<_Const, _Fn, _Views...> {
160	using _Parent _LIBCPP_NODEBUG = __maybe_const<_Const, zip_transform_view>;
161	using _Base _LIBCPP_NODEBUG = __maybe_const<_Const, _InnerView>;
162
163	friend zip_transform_view<_Fn, _Views...>;
164
165	_Parent* __parent_ = nullptr;
166	__ziperator<_Const> __inner_;
167
168	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(_Parent& __parent, __ziperator<_Const> __inner)
169	: __parent_(std::addressof(__parent)), __inner_(std::move(__inner)) {}
170
171	_LIBCPP_HIDE_FROM_ABI constexpr auto __get_deref_and_invoke() const noexcept {
172	return [&__fun = *__parent_->__fun_](const auto&... __iters) noexcept(noexcept(std::invoke(
173	__parent_->__fun_, __iters...))) -> decltype(auto) { return std::invoke(__fun, *__iters...); };
174	}
175
176	public:
177	using iterator_concept = typename __ziperator<_Const>::iterator_concept;
178	using value_type =
179	remove_cvref_t<invoke_result_t<__maybe_const<_Const, _Fn>&, range_reference_t<__maybe_const<_Const, _Views>>...>>;
180	using difference_type = range_difference_t<_Base>;
181
182	_LIBCPP_HIDE_FROM_ABI __iterator() = default;
183	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(__iterator<!_Const> __i)
184	requires _Const && convertible_to<__ziperator<false>, __ziperator<_Const>>
185	: __parent_(__i.__parent_), __inner_(std::move(__i.__inner_)) {}
186
187	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator*() const
188	noexcept(noexcept(std::apply(__get_deref_and_invoke(), __zip_view_iterator_access::__get_underlying(__inner_)))) {
189	return std::apply(__get_deref_and_invoke(), __zip_view_iterator_access::__get_underlying(__inner_));
190	}
191
192	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
193	++__inner_;
194	return *this;
195	}
196
197	_LIBCPP_HIDE_FROM_ABI constexpr void operator++(int) { ++*this; }
198
199	_LIBCPP_HIDE_FROM_ABI constexpr __iterator operator++(int)
200	requires forward_range<_Base>
201	{
202	auto __tmp = *this;
203	++*this;
204	return __tmp;
205	}
206
207	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator--()
208	requires bidirectional_range<_Base>
209	{
210	--__inner_;
211	return *this;
212	}
213
214	_LIBCPP_HIDE_FROM_ABI constexpr __iterator operator--(int)
215	requires bidirectional_range<_Base>
216	{
217	auto __tmp = *this;
218	--*this;
219	return __tmp;
220	}
221
222	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator+=(difference_type __x)
223	requires random_access_range<_Base>
224	{
225	__inner_ += __x;
226	return *this;
227	}
228
229	_LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator-=(difference_type __x)
230	requires random_access_range<_Base>
231	{
232	__inner_ -= __x;
233	return *this;
234	}
235
236	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](difference_type __n) const
237	requires random_access_range<_Base>
238	{
239	return std::apply(
240	[&]<class... _Is>(const _Is&... __iters) -> decltype(auto) {
241	return std::invoke(*__parent_->__fun_, __iters[iter_difference_t<_Is>(__n)]...);
242	},
243	__zip_view_iterator_access::__get_underlying(__inner_));
244	}
245
246	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator& __x, const __iterator& __y)
247	requires equality_comparable<__ziperator<_Const>>
248	{
249	return __x.__inner_ == __y.__inner_;
250	}
251
252	_LIBCPP_HIDE_FROM_ABI friend constexpr auto operator<=>(const __iterator& __x, const __iterator& __y)
253	requires random_access_range<_Base>
254	{
255	return __x.__inner_ <=> __y.__inner_;
256	}
257
258	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(const __iterator& __i, difference_type __n)
259	requires random_access_range<_Base>
260	{
261	return __iterator(*__i.__parent_, __i.__inner_ + __n);
262	}
263
264	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator+(difference_type __n, const __iterator& __i)
265	requires random_access_range<_Base>
266	{
267	return __iterator(*__i.__parent_, __i.__inner_ + __n);
268	}
269
270	_LIBCPP_HIDE_FROM_ABI friend constexpr __iterator operator-(const __iterator& __i, difference_type __n)
271	requires random_access_range<_Base>
272	{
273	return __iterator(*__i.__parent_, __i.__inner_ - __n);
274	}
275
276	_LIBCPP_HIDE_FROM_ABI friend constexpr difference_type operator-(const __iterator& __x, const __iterator& __y)
277	requires sized_sentinel_for<__ziperator<_Const>, __ziperator<_Const>>
278	{
279	return __x.__inner_ - __y.__inner_;
280	}
281	};
282
283	template <move_constructible _Fn, input_range... _Views>
284	requires(view<_Views> && ...) &&
285	(sizeof...(_Views) > 0) && is_object_v<_Fn> && regular_invocable<_Fn&, range_reference_t<_Views>...> &&
286	__referenceable<invoke_result_t<_Fn&, range_reference_t<_Views>...>>
287	template <bool _Const>
288	class zip_transform_view<_Fn, _Views...>::__sentinel {
289	__zentinel<_Const> __inner_;
290
291	friend zip_transform_view<_Fn, _Views...>;
292
293	_LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(__zentinel<_Const> __inner) : __inner_(__inner) {}
294
295	public:
296	_LIBCPP_HIDE_FROM_ABI __sentinel() = default;
297
298	_LIBCPP_HIDE_FROM_ABI constexpr __sentinel(__sentinel<!_Const> __i)
299	requires _Const && convertible_to<__zentinel<false>, __zentinel<_Const>>
300	: __inner_(__i.__inner_) {}
301
302	template <bool _OtherConst>
303	requires sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
304	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
305	return __x.__inner_ == __y.__inner_;
306	}
307
308	template <bool _OtherConst>
309	requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
310	_LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _InnerView>>
311	operator-(const __iterator<_OtherConst>& __x, const __sentinel& __y) {
312	return __x.__inner_ - __y.__inner_;
313	}
314
315	template <bool _OtherConst>
316	requires sized_sentinel_for<__zentinel<_Const>, __ziperator<_OtherConst>>
317	_LIBCPP_HIDE_FROM_ABI friend constexpr range_difference_t<__maybe_const<_OtherConst, _InnerView>>
318	operator-(const __sentinel& __x, const __iterator<_OtherConst>& __y) {
319	return __x.__inner_ - __y.__inner_;
320	}
321	};
322
323	namespace views {
324	namespace __zip_transform {
325
326	struct __fn {
327	template <class _Fn>
328	requires(move_constructible<decay_t<_Fn>> && regular_invocable<decay_t<_Fn>&> &&
329	is_object_v<invoke_result_t<decay_t<_Fn>&>>)
330	_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&&) const
331	noexcept(noexcept(auto(views::empty<decay_t<invoke_result_t<decay_t<_Fn>&>>>))) {
332	return views::empty<decay_t<invoke_result_t<decay_t<_Fn>&>>>;
333	}
334
335	template <class _Fn, class... _Ranges>
336	requires(sizeof...(_Ranges) > 0)
337	_LIBCPP_HIDE_FROM_ABI constexpr auto operator()(_Fn&& __fun, _Ranges&&... __rs) const
338	noexcept(noexcept(zip_transform_view(std::forward<_Fn>(__fun), std::forward<_Ranges>(__rs)...)))
339	-> decltype(zip_transform_view(std::forward<_Fn>(__fun), std::forward<_Ranges>(__rs)...)) {
340	return zip_transform_view(std::forward<_Fn>(__fun), std::forward<_Ranges>(__rs)...);
341	}
342	};
343
344	} // namespace __zip_transform
345	inline namespace __cpo {
346	inline constexpr auto zip_transform = __zip_transform::__fn{};
347	} // namespace __cpo
348	} // namespace views
349	} // namespace ranges
350
351	#endif // _LIBCPP_STD_VER >= 23
352
353	_LIBCPP_END_NAMESPACE_STD
354
355	_LIBCPP_POP_MACROS
356
357	#endif // _LIBCPP___RANGES_ZIP_TRANSFORM_VIEW_H

lib/libcxx/include/__ranges/zip_view.h+20-20

 @@ -31,6 +31,7 @@
 #include <__ranges/enable_borrowed_range.h>
 #include <__ranges/size.h>
 #include <__ranges/view_interface.h>
+#include <__tuple/tuple_transform.h>
 #include <__type_traits/is_nothrow_constructible.h>
 #include <__type_traits/make_unsigned.h>
 #include <__utility/declval.h>
 @@ -58,15 +59,6 @@ concept __zip_is_common =
     (!(bidirectional_range<_Ranges> && ...) && (common_range<_Ranges> && ...)) ||
     ((random_access_range<_Ranges> && ...) && (sized_range<_Ranges> && ...));
-template <class _Fun, class _Tuple>
-_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_transform(_Fun&& __f, _Tuple&& __tuple) {
-  return std::apply(
-      [&]<class... _Types>(_Types&&... __elements) {
-        return tuple<invoke_result_t<_Fun&, _Types>...>(std::invoke(__f, std::forward<_Types>(__elements))...);
-      },
-      std::forward<_Tuple>(__tuple));
-}
 template <class _Fun, class _Tuple>
 _LIBCPP_HIDE_FROM_ABI constexpr void __tuple_for_each(_Fun&& __f, _Tuple&& __tuple) {
   std::apply(
 @@ -145,24 +137,24 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
     requires(!(__simple_view<_Views> && ...))
   {
-    return __iterator<false>(ranges::__tuple_transform(ranges::begin, __views_));
+    return __iterator<false>(std::__tuple_transform(ranges::begin, __views_));
   }
   _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
     requires(range<const _Views> && ...)
   {
-    return __iterator<true>(ranges::__tuple_transform(ranges::begin, __views_));
+    return __iterator<true>(std::__tuple_transform(ranges::begin, __views_));
   }
   _LIBCPP_HIDE_FROM_ABI constexpr auto end()
     requires(!(__simple_view<_Views> && ...))
   {
     if constexpr (!__zip_is_common<_Views...>) {
-      return __sentinel<false>(ranges::__tuple_transform(ranges::end, __views_));
+      return __sentinel<false>(std::__tuple_transform(ranges::end, __views_));
     } else if constexpr ((random_access_range<_Views> && ...)) {
       return begin() + iter_difference_t<__iterator<false>>(size());
     } else {
-      return __iterator<false>(ranges::__tuple_transform(ranges::end, __views_));
+      return __iterator<false>(std::__tuple_transform(ranges::end, __views_));
     }
   }
 @@ -170,11 +162,11 @@ public:
     requires(range<const _Views> && ...)
   {
     if constexpr (!__zip_is_common<const _Views...>) {
-      return __sentinel<true>(ranges::__tuple_transform(ranges::end, __views_));
+      return __sentinel<true>(std::__tuple_transform(ranges::end, __views_));
     } else if constexpr ((random_access_range<const _Views> && ...)) {
       return begin() + iter_difference_t<__iterator<true>>(size());
     } else {
-      return __iterator<true>(ranges::__tuple_transform(ranges::end, __views_));
+      return __iterator<true>(std::__tuple_transform(ranges::end, __views_));
     }
   }
 @@ -186,7 +178,7 @@ public:
           using _CT = make_unsigned_t<common_type_t<decltype(__sizes)...>>;
           return ranges::min({_CT(__sizes)...});
         },
-        ranges::__tuple_transform(ranges::size, __views_));
+        std::__tuple_transform(ranges::size, __views_));
   }
   _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
 @@ -197,7 +189,7 @@ public:
           using _CT = make_unsigned_t<common_type_t<decltype(__sizes)...>>;
           return ranges::min({_CT(__sizes)...});
         },
-        ranges::__tuple_transform(ranges::size, __views_));
+        std::__tuple_transform(ranges::size, __views_));
   }
 };
 @@ -235,6 +227,13 @@ struct __zip_view_iterator_category_base<_Const, _Views...> {
   using iterator_category = input_iterator_tag;
 };
+struct __zip_view_iterator_access {
+  template <class _Iter>
+  _LIBCPP_HIDE_FROM_ABI static constexpr decltype(auto) __get_underlying(_Iter& __iter) noexcept {
+    return (__iter.__current_);
+  }
+};
 template <input_range... _Views>
   requires(view<_Views> && ...) && (sizeof...(_Views) > 0)
 template <bool _Const>
 @@ -255,6 +254,7 @@ class zip_view<_Views...>::__iterator : public __zip_view_iterator_category_base
   static constexpr bool __is_zip_view_iterator = true;
   friend struct __product_iterator_traits<__iterator>;
+  friend __zip_view_iterator_access;
 public:
   using iterator_concept = decltype(ranges::__get_zip_view_iterator_tag<_Const, _Views...>());
 @@ -268,7 +268,7 @@ public:
       : __current_(std::move(__i.__current_)) {}
   _LIBCPP_HIDE_FROM_ABI constexpr auto operator*() const {
-    return ranges::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
+    return std::__tuple_transform([](auto& __i) -> decltype(auto) { return *__i; }, __current_);
   }
   _LIBCPP_HIDE_FROM_ABI constexpr __iterator& operator++() {
 @@ -318,7 +318,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr auto operator[](difference_type __n) const
     requires __zip_all_random_access<_Const, _Views...>
   {
-    return ranges::__tuple_transform(
+    return std::__tuple_transform(
         [&]<class _Iter>(_Iter& __i) -> decltype(auto) { return __i[iter_difference_t<_Iter>(__n)]; }, __current_);
   }
 @@ -377,7 +377,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI friend constexpr auto iter_move(const __iterator& __i) noexcept(
       (noexcept(ranges::iter_move(std::declval<const iterator_t<__maybe_const<_Const, _Views>>&>())) && ...) &&
       (is_nothrow_move_constructible_v<range_rvalue_reference_t<__maybe_const<_Const, _Views>>> && ...)) {
-    return ranges::__tuple_transform(ranges::iter_move, __i.__current_);
+    return std::__tuple_transform(ranges::iter_move, __i.__current_);
   }
   _LIBCPP_HIDE_FROM_ABI friend constexpr void iter_swap(const __iterator& __l, const __iterator& __r) noexcept(

lib/libcxx/include/__split_buffer+612-240

...	@@ -13,10 +13,12 @@	...	@@ -13,10 +13,12 @@
13	#include <__algorithm/max.h>	13	#include <__algorithm/max.h>
14	#include <__algorithm/move.h>	14	#include <__algorithm/move.h>
15	#include <__algorithm/move_backward.h>	15	#include <__algorithm/move_backward.h>
		16	#include <__assert>
16	#include <__config>	17	#include <__config>
17	#include <__iterator/distance.h>	18	#include <__iterator/distance.h>
18	#include <__iterator/iterator_traits.h>	19	#include <__iterator/iterator_traits.h>
19	#include <__iterator/move_iterator.h>	20	#include <__iterator/move_iterator.h>
		21	#include <__memory/addressof.h>
20	#include <__memory/allocate_at_least.h>	22	#include <__memory/allocate_at_least.h>
21	#include <__memory/allocator.h>	23	#include <__memory/allocator.h>
22	#include <__memory/allocator_traits.h>	24	#include <__memory/allocator_traits.h>
...	@@ -28,11 +30,9 @@	...	@@ -28,11 +30,9 @@
28	#include <__type_traits/integral_constant.h>	30	#include <__type_traits/integral_constant.h>
29	#include <__type_traits/is_nothrow_assignable.h>	31	#include <__type_traits/is_nothrow_assignable.h>
30	#include <__type_traits/is_nothrow_constructible.h>	32	#include <__type_traits/is_nothrow_constructible.h>
31	#include <__type_traits/is_replaceable.h>
32	#include <__type_traits/is_swappable.h>	33	#include <__type_traits/is_swappable.h>
33	#include <__type_traits/is_trivially_destructible.h>	34	#include <__type_traits/is_trivially_destructible.h>
34	#include <__type_traits/is_trivially_relocatable.h>	35	#include <__type_traits/is_trivially_relocatable.h>
35	#include <__type_traits/remove_reference.h>
36	#include <__utility/forward.h>	36	#include <__utility/forward.h>
37	#include <__utility/move.h>	37	#include <__utility/move.h>
38		38
...	@@ -45,25 +45,430 @@ _LIBCPP_PUSH_MACROS	...	@@ -45,25 +45,430 @@ _LIBCPP_PUSH_MACROS
45		45
46	_LIBCPP_BEGIN_NAMESPACE_STD	46	_LIBCPP_BEGIN_NAMESPACE_STD
47		47
48	// __split_buffer allocates a contiguous chunk of memory and stores objects in the range [__begin_, __end_).	48	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
49	// It has uninitialized memory in the ranges [__first_, __begin_) and [__end_, __cap_). That allows	49	class __split_buffer;
50	// it to grow both in the front and back without having to move the data.	50
		51	template <class _SplitBuffer, class _Tp, class _Allocator>
		52	class __split_buffer_pointer_layout {
		53	protected:
		54	using value_type = _Tp;
		55	using allocator_type = _Allocator;
		56	using __alloc_traits _LIBCPP_NODEBUG = allocator_traits<allocator_type>;
		57	using reference = value_type&;
		58	using const_reference = const value_type&;
		59	using size_type = typename __alloc_traits::size_type;
		60	using difference_type = typename __alloc_traits::difference_type;
		61	using pointer = typename __alloc_traits::pointer;
		62	using const_pointer = typename __alloc_traits::const_pointer;
		63	using iterator = pointer;
		64	using const_iterator = const_pointer;
		65	using __sentinel_type _LIBCPP_NODEBUG = pointer;
51		66
52	template <class _Tp, class _Allocator = allocator<_Tp> >
53	struct __split_buffer {
54	public:	67	public:
55	using value_type = _Tp;	68	// Can't be defaulted due to _LIBCPP_COMPRESSED_PAIR not being an aggregate in C++03 and C++11.
56	using allocator_type = _Allocator;	69	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer_pointer_layout() : __back_cap_(nullptr) {}
57	using __alloc_rr _LIBCPP_NODEBUG = __libcpp_remove_reference_t<allocator_type>;	70
58	using __alloc_traits _LIBCPP_NODEBUG = allocator_traits<__alloc_rr>;	71	_LIBCPP_CONSTEXPR_SINCE_CXX20
59	using reference = value_type&;	72	_LIBCPP_HIDE_FROM_ABI explicit __split_buffer_pointer_layout(const allocator_type& __alloc)
60	using const_reference = const value_type&;	73	: __back_cap_(nullptr), __alloc_(__alloc) {}
61	using size_type = typename __alloc_traits::size_type;	74
62	using difference_type = typename __alloc_traits::difference_type;	75	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer __front_cap() _NOEXCEPT { return __front_cap_; }
63	using pointer = typename __alloc_traits::pointer;	76
64	using const_pointer = typename __alloc_traits::const_pointer;	77	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_pointer __front_cap() const _NOEXCEPT {
65	using iterator = pointer;	78	return __front_cap_;
66	using const_iterator = const_pointer;	79	}
		80
		81	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer begin() _NOEXCEPT { return __begin_; }
		82
		83	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_pointer begin() const _NOEXCEPT { return __begin_; }
		84
		85	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer end() _NOEXCEPT { return __end_; }
		86
		87	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer end() const _NOEXCEPT { return __end_; }
		88
		89	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT {
		90	return static_cast<size_type>(__end_ - __begin_);
		91	}
		92
		93	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __begin_ == __end_; }
		94
		95	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type capacity() const _NOEXCEPT {
		96	return static_cast<size_type>(__back_cap_ - __front_cap_);
		97	}
		98
		99	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type& __get_allocator() _NOEXCEPT { return __alloc_; }
		100
		101	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type const& __get_allocator() const _NOEXCEPT {
		102	return __alloc_;
		103	}
		104
		105	// Returns the sentinel object directly. Should be used in conjunction with automatic type deduction,
		106	// not explicit types.
		107	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __sentinel_type __raw_sentinel() const _NOEXCEPT {
		108	return __end_;
		109	}
		110	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __sentinel_type __raw_capacity() const _NOEXCEPT {
		111	return __back_cap_;
		112	}
		113
		114	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_data(pointer __new_first) _NOEXCEPT {
		115	__front_cap_ = __new_first;
		116	}
		117
		118	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		119	__set_valid_range(pointer __new_begin, pointer __new_end) _NOEXCEPT {
		120	__begin_ = __new_begin;
		121	__end_ = __new_end;
		122	}
		123
		124	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		125	__set_valid_range(pointer __new_begin, size_type __new_size) _NOEXCEPT {
		126	__begin_ = __new_begin;
		127	__end_ = __begin_ + __new_size;
		128	}
		129
		130	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_sentinel(pointer __new_end) _NOEXCEPT {
		131	_LIBCPP_ASSERT_INTERNAL(__front_cap_ <= __new_end, "__new_end cannot precede __front_cap_");
		132	__end_ = __new_end;
		133	}
		134
		135	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_sentinel(size_type __new_size) _NOEXCEPT {
		136	__end_ = __begin_ + __new_size;
		137	}
		138
		139	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_capacity(size_type __new_capacity) _NOEXCEPT {
		140	__back_cap_ = __front_cap_ + __new_capacity;
		141	}
		142
		143	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_capacity(pointer __new_capacity) _NOEXCEPT {
		144	__back_cap_ = __new_capacity;
		145	}
		146
		147	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __front_spare() const _NOEXCEPT {
		148	return static_cast<size_type>(__begin_ - __front_cap_);
		149	}
		150
		151	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __back_spare() const _NOEXCEPT {
		152	return static_cast<size_type>(__back_cap_ - __end_);
		153	}
		154
		155	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT { return *(__end_ - 1); }
		156
		157	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT { return *(__end_ - 1); }
		158
		159	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __swap_without_allocator(
		160	__split_buffer_pointer_layout<__split_buffer<value_type, allocator_type, __split_buffer_pointer_layout>,
		161	value_type,
		162	allocator_type>& __other) _NOEXCEPT {
		163	std::swap(__front_cap_, __other.__front_cap_);
		164	std::swap(__begin_, __other.__begin_);
		165	std::swap(__back_cap_, __other.__back_cap_);
		166	std::swap(__end_, __other.__end_);
		167	}
		168
		169	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(__split_buffer_pointer_layout& __other) _NOEXCEPT {
		170	std::swap(__front_cap_, __other.__front_cap_);
		171	std::swap(__begin_, __other.__begin_);
		172	std::swap(__back_cap_, __other.__back_cap_);
		173	std::swap(__end_, __other.__end_);
		174	std::__swap_allocator(__alloc_, __other.__alloc_);
		175	}
		176
		177	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __reset() _NOEXCEPT {
		178	__front_cap_ = nullptr;
		179	__begin_ = nullptr;
		180	__end_ = nullptr;
		181	__back_cap_ = nullptr;
		182	}
		183
		184	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		185	__copy_without_alloc(__split_buffer_pointer_layout const& __other)
		186	_NOEXCEPT_(is_nothrow_copy_assignable<pointer>::value) {
		187	__front_cap_ = __other.__front_cap_;
		188	__begin_ = __other.__begin_;
		189	__end_ = __other.__end_;
		190	__back_cap_ = __other.__back_cap_;
		191	}
		192
		193	private:
		194	pointer __front_cap_ = nullptr;
		195	pointer __begin_ = nullptr;
		196	pointer __end_ = nullptr;
		197	_LIBCPP_COMPRESSED_PAIR(pointer, __back_cap_, allocator_type, __alloc_);
		198
		199	template <class, class, class>
		200	friend class __split_buffer_pointer_layout;
		201	};
		202
		203	template <class _SplitBuffer, class _Tp, class _Allocator>
		204	class __split_buffer_size_layout {
		205	protected:
		206	using value_type = _Tp;
		207	using allocator_type = _Allocator;
		208	using __alloc_traits _LIBCPP_NODEBUG = allocator_traits<allocator_type>;
		209	using reference = value_type&;
		210	using const_reference = const value_type&;
		211	using size_type = typename __alloc_traits::size_type;
		212	using difference_type = typename __alloc_traits::difference_type;
		213	using pointer = typename __alloc_traits::pointer;
		214	using const_pointer = typename __alloc_traits::const_pointer;
		215	using iterator = pointer;
		216	using const_iterator = const_pointer;
		217	using __sentinel_type _LIBCPP_NODEBUG = size_type;
		218
		219	public:
		220	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer_size_layout() = default;
		221
		222	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit __split_buffer_size_layout(const allocator_type& __alloc)
		223	: __alloc_(__alloc) {}
		224
		225	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer __front_cap() _NOEXCEPT { return __front_cap_; }
		226
		227	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_pointer __front_cap() const _NOEXCEPT {
		228	return __front_cap_;
		229	}
		230
		231	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer begin() _NOEXCEPT { return __begin_; }
		232
		233	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_pointer begin() const _NOEXCEPT { return __begin_; }
		234
		235	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer end() _NOEXCEPT { return __begin_ + __size_; }
		236
		237	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer end() const _NOEXCEPT { return __begin_ + __size_; }
		238
		239	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
		240
		241	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __size_ == 0; }
		242
		243	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type capacity() const _NOEXCEPT { return __cap_; }
		244
		245	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type& __get_allocator() _NOEXCEPT { return __alloc_; }
		246
		247	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type const& __get_allocator() const _NOEXCEPT {
		248	return __alloc_;
		249	}
		250
		251	// Returns the sentinel object directly. Should be used in conjunction with automatic type deduction,
		252	// not explicit types.
		253	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __sentinel_type __raw_sentinel() const _NOEXCEPT {
		254	return __size_;
		255	}
		256	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __sentinel_type __raw_capacity() const _NOEXCEPT {
		257	return __cap_;
		258	}
		259
		260	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_data(pointer __new_first) _NOEXCEPT {
		261	__front_cap_ = __new_first;
		262	}
		263
		264	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		265	__set_valid_range(pointer __new_begin, pointer __new_end) _NOEXCEPT {
		266	// Size-based __split_buffers track their size directly: we need to explicitly update the size
		267	// when the front is adjusted.
		268	__size_ -= __new_begin - __begin_;
		269	__begin_ = __new_begin;
		270	__set_sentinel(__new_end);
		271	}
		272
		273	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		274	__set_valid_range(pointer __new_begin, size_type __new_size) _NOEXCEPT {
		275	// Size-based __split_buffers track their size directly: we need to explicitly update the size
		276	// when the front is adjusted.
		277	__size_ -= __new_begin - __begin_;
		278	__begin_ = __new_begin;
		279	__set_sentinel(__new_size);
		280	}
		281
		282	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_sentinel(pointer __new_end) _NOEXCEPT {
		283	_LIBCPP_ASSERT_INTERNAL(__front_cap_ <= __new_end, "__new_end cannot precede __front_cap_");
		284	__size_ += __new_end - end();
		285	}
		286
		287	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_sentinel(size_type __new_size) _NOEXCEPT {
		288	__size_ = __new_size;
		289	}
		290
		291	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_capacity(size_type __new_capacity) _NOEXCEPT {
		292	__cap_ = __new_capacity;
		293	}
		294
		295	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __set_capacity(pointer __new_capacity) _NOEXCEPT {
		296	__cap_ = __new_capacity - __begin_;
		297	}
		298
		299	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __front_spare() const _NOEXCEPT {
		300	return static_cast<size_type>(__begin_ - __front_cap_);
		301	}
		302
		303	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __back_spare() const _NOEXCEPT {
		304	// `__cap_ - __end_` tells us the total number of spares when in size-mode. We need to remove
		305	// the __front_spare from the count.
		306	return __cap_ - __size_ - __front_spare();
		307	}
		308
		309	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT { return __begin_[__size_ - 1]; }
		310
		311	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
		312	return __begin_[__size_ - 1];
		313	}
		314
		315	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __swap_without_allocator(
		316	__split_buffer_pointer_layout<__split_buffer<value_type, allocator_type, __split_buffer_pointer_layout>,
		317	value_type,
		318	allocator_type>& __other) _NOEXCEPT {
		319	std::swap(__front_cap_, __other.__front_cap_);
		320	std::swap(__begin_, __other.__begin_);
		321	std::swap(__cap_, __other.__cap_);
		322	std::swap(__size_, __other.__size_);
		323	}
		324
		325	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(__split_buffer_size_layout& __other) _NOEXCEPT {
		326	std::swap(__front_cap_, __other.__front_cap_);
		327	std::swap(__begin_, __other.__begin_);
		328	std::swap(__cap_, __other.__cap_);
		329	std::swap(__size_, __other.__size_);
		330	std::__swap_allocator(__alloc_, __other.__alloc_);
		331	}
		332
		333	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __reset() _NOEXCEPT {
		334	__front_cap_ = nullptr;
		335	__begin_ = nullptr;
		336	__size_ = 0;
		337	__cap_ = 0;
		338	}
		339
		340	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		341	__copy_without_alloc(__split_buffer_size_layout const& __other)
		342	_NOEXCEPT_(is_nothrow_copy_assignable<pointer>::value) {
		343	__front_cap_ = __other.__front_cap_;
		344	__begin_ = __other.__begin_;
		345	__cap_ = __other.__cap_;
		346	__size_ = __other.__size_;
		347	}
		348
		349	private:
		350	pointer __front_cap_ = nullptr;
		351	pointer __begin_ = nullptr;
		352	size_type __size_ = 0;
		353	size_type __cap_ = 0;
		354	_LIBCPP_NO_UNIQUE_ADDRESS allocator_type __alloc_;
		355
		356	template <class, class, class>
		357	friend class __split_buffer_size_layout;
		358	};
		359
		360	// `__split_buffer` is a contiguous array data structure. It may hold spare capacity at both ends of
		361	// the sequence. This allows for a `__split_buffer` to grow from both the front and the back without
		362	// relocating its contents until it runs out of room. This characteristic sets it apart from
		363	// `std::vector`, which only holds spare capacity at its end. As such, `__split_buffer` is useful
		364	// for implementing both `std::vector` and `std::deque`.
		365	//
		366	// The sequence is stored as a contiguous chunk of memory delimited by the following "pointers" (`o` denotes
		367	// uninitialized memory and `x` denotes a valid object):
		368	//
		369	// \|oooooooooooooooooooxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxoooooooooooooooooooooooo\|
		370	// ^ ^ ^ ^
		371	// __front_cap_ __begin_ __end_ __back_cap_
		372	//
		373	// The range [__front_cap_, __begin_) contains uninitialized memory. It is referred to as the "front spare capacity".
		374	// The range [__begin_, __end_) contains valid objects. It is referred to as the "valid range".
		375	// The range [__end_, __back_cap_) contains uninitialized memory. It is referred to as the "back spare capacity".
		376	//
		377	// The layout of `__split_buffer` is determined by the `_Layout` template template parameter. This
		378	// `_Layout` allows the above pointers to be stored as different representations, such as integer
		379	// offsets. A layout class template must provide the following interface:
		380	//
		381	// template<class _Tp, class _Allocator, class _Layout>
		382	// class __layout {
		383	// protected:
		384	// using value_type = _Tp;
		385	// using allocator_type = _Allocator;
		386	// using __alloc_traits = allocator_traits<allocator_type>;
		387	// using reference = value_type&;
		388	// using const_reference = const value_type&;
		389	// using size_type = typename __alloc_traits::size_type;
		390	// using difference_type = typename __alloc_traits::difference_type;
		391	// using pointer = typename __alloc_traits::pointer;
		392	// using const_pointer = typename __alloc_traits::const_pointer;
		393	// using iterator = pointer;
		394	// using const_iterator = const_pointer;
		395	// using __sentinel_type = /* type that represents the layout's sentinel */;
		396	//
		397	// public:
		398	// __layout() = default;
		399	// explicit __layout(const allocator_type&);
		400	//
		401	// pointer __front_cap();
		402	// const_pointer __front_cap() const;
		403	//
		404	// pointer begin();
		405	// const_pointer begin() const;
		406	//
		407	// pointer end();
		408	// pointer end() const;
		409	//
		410	// size_type size() const;
		411	// bool empty() const;
		412	// size_type capacity() const;
		413	//
		414	// allocator_type& __get_allocator();
		415	// allocator_type const& __get_allocator() const;
		416	//
		417	// __sentinel_type __raw_sentinel() const;
		418	// __sentinel_type __raw_capacity() const;
		419	//
		420	// void __set_data(pointer);
		421	// void __set_valid_range(pointer __begin, pointer __end);
		422	// void __set_valid_range(pointer __begin, size_type __size);
		423	// void __set_sentinel(pointer __end);
		424	// void __set_sentinel(size_type __size);
		425	//
		426	// void __set_capacity(size_type __capacity);
		427	// void __set_capacity(pointer __capacity);
		428	//
		429	// size_type __front_spare() const;
		430	// size_type __back_spare() const;
		431	//
		432	// reference back();
		433	// const_reference back() const;
		434	//
		435	// template<class _OtherLayout>
		436	// void __swap_without_allocator(_OtherLayout&);
		437	// void swap(__layout&);
		438	//
		439	// void __reset();
		440	// void __copy_without_alloc(__layout const&);
		441	// };
		442	//
		443	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
		444	class __split_buffer : _Layout<__split_buffer<_Tp, _Allocator, _Layout>, _Tp, _Allocator> {
		445	using __base_type _LIBCPP_NODEBUG = _Layout<__split_buffer<_Tp, _Allocator, _Layout>, _Tp, _Allocator>;
		446
		447	public:
		448	using __base_type::__back_spare;
		449	using __base_type::__copy_without_alloc;
		450	using __base_type::__front_cap;
		451	using __base_type::__front_spare;
		452	using __base_type::__get_allocator;
		453	using __base_type::__raw_capacity;
		454	using __base_type::__raw_sentinel;
		455	using __base_type::__reset;
		456	using __base_type::__set_capacity;
		457	using __base_type::__set_data;
		458	using __base_type::__set_sentinel;
		459	using __base_type::__set_valid_range;
		460
		461	using typename __base_type::__alloc_traits;
		462	using typename __base_type::allocator_type;
		463	using typename __base_type::const_iterator;
		464	using typename __base_type::const_pointer;
		465	using typename __base_type::const_reference;
		466	using typename __base_type::difference_type;
		467	using typename __base_type::iterator;
		468	using typename __base_type::pointer;
		469	using typename __base_type::reference;
		470	using typename __base_type::size_type;
		471	using typename __base_type::value_type;
67		472
68	// A __split_buffer contains the following members which may be trivially relocatable:	473	// A __split_buffer contains the following members which may be trivially relocatable:
69	// - pointer: may be trivially relocatable, so it's checked	474	// - pointer: may be trivially relocatable, so it's checked
...	@@ -73,36 +478,24 @@ public:	...	@@ -73,36 +478,24 @@ public:
73	__libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,	478	__libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,
74	__split_buffer,	479	__split_buffer,
75	void>;	480	void>;
76	using __replaceable _LIBCPP_NODEBUG =
77	__conditional_t<__is_replaceable_v<pointer> && __container_allocator_is_replaceable<__alloc_traits>::value,
78	__split_buffer,
79	void>;
80
81	pointer __first_;
82	pointer __begin_;
83	pointer __end_;
84	_LIBCPP_COMPRESSED_PAIR(pointer, __cap_, allocator_type, __alloc_);
85		481
86	__split_buffer(const __split_buffer&) = delete;	482	__split_buffer(const __split_buffer&) = delete;
87	__split_buffer& operator=(const __split_buffer&) = delete;	483	__split_buffer& operator=(const __split_buffer&) = delete;
88		484
89	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer()	485	_LIBCPP_HIDE_FROM_ABI __split_buffer() = default;
90	_NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
91	: __first_(nullptr), __begin_(nullptr), __end_(nullptr), __cap_(nullptr) {}
92		486
93	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit __split_buffer(__alloc_rr& __a)	487	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit __split_buffer(allocator_type& __a) : __base_type(__a) {}
94	: __first_(nullptr), __begin_(nullptr), __end_(nullptr), __cap_(nullptr), __alloc_(__a) {}
95		488
96	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit __split_buffer(const __alloc_rr& __a)	489	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI explicit __split_buffer(const allocator_type& __a)
97	: __first_(nullptr), __begin_(nullptr), __end_(nullptr), __cap_(nullptr), __alloc_(__a) {}	490	: __base_type(__a) {}
98		491
99	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI	492	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
100	__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);	493	__split_buffer(size_type __cap, size_type __start, allocator_type& __a);
101		494
102	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer(__split_buffer&& __c)	495	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer(__split_buffer&& __c)
103	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);	496	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
104		497
105	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);	498	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer(__split_buffer&& __c, const allocator_type& __a);
106		499
107	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer& operator=(__split_buffer&& __c)	500	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI __split_buffer& operator=(__split_buffer&& __c)
108	_NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&	501	_NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
...	@@ -111,36 +504,16 @@ public:	...	@@ -111,36 +504,16 @@ public:
111		504
112	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~__split_buffer();	505	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~__split_buffer();
113		506
114	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __begin_; }	507	using __base_type::back;
115	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __begin_; }	508	using __base_type::begin;
116		509	using __base_type::capacity;
117	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __end_; }	510	using __base_type::empty;
118	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __end_; }	511	using __base_type::end;
119		512	using __base_type::size;
120	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __destruct_at_end(__begin_); }
121		513
122	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type size() const {	514	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void clear() _NOEXCEPT { __destruct_at_end(begin()); }
123	return static_cast<size_type>(__end_ - __begin_);	515	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference front() { return *begin(); }
124	}	516	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference front() const { return *begin(); }
125
126	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool empty() const { return __end_ == __begin_; }
127
128	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type capacity() const {
129	return static_cast<size_type>(__cap_ - __first_);
130	}
131
132	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __front_spare() const {
133	return static_cast<size_type>(__begin_ - __first_);
134	}
135
136	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type __back_spare() const {
137	return static_cast<size_type>(__cap_ - __end_);
138	}
139
140	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference front() { return *__begin_; }
141	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference front() const { return *__begin_; }
142	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference back() { return *(__end_ - 1); }
143	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back() const { return *(__end_ - 1); }
144		517
145	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void shrink_to_fit() _NOEXCEPT;	518	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void shrink_to_fit() _NOEXCEPT;
146		519
...	@@ -149,8 +522,8 @@ public:	...	@@ -149,8 +522,8 @@ public:
149	template <class... _Args>	522	template <class... _Args>
150	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args);	523	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args);
151		524
152	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void pop_front() { __destruct_at_begin(__begin_ + 1); }	525	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void pop_front() { __destruct_at_begin(begin() + 1); }
153	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void pop_back() { __destruct_at_end(__end_ - 1); }	526	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void pop_back() { __destruct_at_end(end() - 1); }
154		527
155	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n);	528	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n);
156	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n, const_reference __x);	529	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __construct_at_end(size_type __n, const_reference __x);
...	@@ -182,244 +555,242 @@ public:	...	@@ -182,244 +555,242 @@ public:
182	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;	555	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
183		556
184	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(__split_buffer& __x)	557	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void swap(__split_buffer& __x)
185	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\| __is_nothrow_swappable_v<__alloc_rr>);	558	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\| __is_nothrow_swappable_v<allocator_type>);
		559
		560	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __invariants() const {
		561	if (__front_cap() == nullptr) {
		562	if (begin() != nullptr)
		563	return false;
		564
		565	if (!empty())
		566	return false;
		567
		568	if (capacity() != 0)
		569	return false;
		570
		571	return true;
		572	} else {
		573	if (begin() < __front_cap())
		574	return false;
186		575
187	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool __invariants() const;	576	if (capacity() < size())
		577	return false;
		578
		579	if (end() < begin())
		580	return false;
		581
		582	return true;
		583	}
		584	}
		585
		586	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
		587	__swap_without_allocator(__split_buffer<value_type, allocator_type, _Layout>& __other) _NOEXCEPT {
		588	__base_type::__swap_without_allocator(__other);
		589	}
188		590
189	private:	591	private:
190	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__split_buffer& __c, true_type)	592	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__split_buffer& __c, true_type)
191	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {	593	_NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value) {
192	__alloc_ = std::move(__c.__alloc_);	594	__get_allocator() = std::move(__c.__get_allocator());
193	}	595	}
194		596
195	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT {}	597	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__split_buffer&, false_type) _NOEXCEPT {}
196		598
197	struct _ConstructTransaction {	599	struct _ConstructTransaction {
198	_LIBCPP_CONSTEXPR_SINCE_CXX20	600	_LIBCPP_CONSTEXPR_SINCE_CXX20
199	_LIBCPP_HIDE_FROM_ABI explicit _ConstructTransaction(pointer* __p, size_type __n) _NOEXCEPT	601	_LIBCPP_HIDE_FROM_ABI explicit _ConstructTransaction(__split_buffer* __parent, pointer __p, size_type __n) _NOEXCEPT
200	: __pos_(*__p),	602	: __pos_(__p),
201	__end_(*__p + __n),	603	__end_(__p + __n),
202	__dest_(__p) {}	604	__parent_(__parent) {}
203		605
204	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~_ConstructTransaction() { *__dest_ = __pos_; }	606	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI ~_ConstructTransaction() { __parent_->__set_sentinel(__pos_); }
205		607
206	pointer __pos_;	608	pointer __pos_;
207	const pointer __end_;	609	const pointer __end_;
208		610
209	private:	611	private:
210	pointer* __dest_;	612	__split_buffer* __parent_;
211	};	613	};
212	};
213		614
214	template <class _Tp, class _Allocator>	615	template <class _T2, class _A2, template <class, class, class> class _L2>
215	_LIBCPP_CONSTEXPR_SINCE_CXX20 bool __split_buffer<_Tp, _Allocator>::__invariants() const {	616	friend class __split_buffer;
216	if (__first_ == nullptr) {	617	};
217	if (__begin_ != nullptr)
218	return false;
219	if (__end_ != nullptr)
220	return false;
221	if (__cap_ != nullptr)
222	return false;
223	} else {
224	if (__begin_ < __first_)
225	return false;
226	if (__end_ < __begin_)
227	return false;
228	if (__cap_ < __end_)
229	return false;
230	}
231	return true;
232	}
233		618
234	// Default constructs __n objects starting at __end_	619	// Default constructs __n objects starting at `end()`
235	// throws if construction throws	620	// throws if construction throws
236	// Precondition: __n > 0	621	// Precondition: __n > 0
237	// Precondition: size() + __n <= capacity()	622	// Precondition: size() + __n <= capacity()
238	// Postcondition: size() == size() + __n	623	// Postcondition: size() == size() + __n
239	template <class _Tp, class _Allocator>	624	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
240	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n) {	625	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator, _Layout>::__construct_at_end(size_type __n) {
241	_ConstructTransaction __tx(std::addressof(this->__end_), __n);	626	_ConstructTransaction __tx(this, end(), __n);
242	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {	627	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
243	__alloc_traits::construct(__alloc_, std::__to_address(__tx.__pos_));	628	__alloc_traits::construct(__get_allocator(), std::__to_address(__tx.__pos_));
244	}	629	}
245	}	630	}
246		631
247	// Copy constructs __n objects starting at __end_ from __x	632	// Copy constructs __n objects starting at `end()` from __x
248	// throws if construction throws	633	// throws if construction throws
249	// Precondition: __n > 0	634	// Precondition: __n > 0
250	// Precondition: size() + __n <= capacity()	635	// Precondition: size() + __n <= capacity()
251	// Postcondition: size() == old size() + __n	636	// Postcondition: size() == old size() + __n
252	// Postcondition: [i] == __x for all i in [size() - __n, __n)	637	// Postcondition: [i] == __x for all i in [size() - __n, __n)
253	template <class _Tp, class _Allocator>	638	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
254	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	639	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
255	__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x) {	640	__split_buffer<_Tp, _Allocator, _Layout>::__construct_at_end(size_type __n, const_reference __x) {
256	_ConstructTransaction __tx(std::addressof(this->__end_), __n);	641	_ConstructTransaction __tx(this, end(), __n);
257	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {	642	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_) {
258	__alloc_traits::construct(__alloc_, std::__to_address(__tx.__pos_), __x);	643	__alloc_traits::construct(__get_allocator(), std::__to_address(__tx.__pos_), __x);
259	}	644	}
260	}	645	}
261		646
262	template <class _Tp, class _Allocator>	647	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
263	template <class _Iterator, class _Sentinel>	648	template <class _Iterator, class _Sentinel>
264	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	649	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
265	__split_buffer<_Tp, _Allocator>::__construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last) {	650	__split_buffer<_Tp, _Allocator, _Layout>::__construct_at_end_with_sentinel(_Iterator __first, _Sentinel __last) {
266	__alloc_rr& __a = __alloc_;	651	allocator_type& __a = __get_allocator();
267	for (; __first != __last; ++__first) {	652	for (; __first != __last; ++__first) {
268	if (__end_ == __cap_) {	653	if (__back_spare() == 0) {
269	size_type __old_cap = __cap_ - __first_;	654	size_type __old_cap = capacity();
270	size_type __new_cap = std::max<size_type>(2 * __old_cap, 8);	655	size_type __new_cap = std::max<size_type>(2 * __old_cap, 8);
271	__split_buffer __buf(__new_cap, 0, __a);	656	__split_buffer __buf(__new_cap, 0, __a);
272	for (pointer __p = __begin_; __p != __end_; ++__p, (void)++__buf.__end_)	657	pointer __buf_end = __buf.end();
273	__alloc_traits::construct(__buf.__alloc_, std::__to_address(__buf.__end_), std::move(*__p));	658	pointer __end = end();
		659	for (pointer __p = begin(); __p != __end; ++__p) {
		660	__alloc_traits::construct(__buf.__get_allocator(), std::__to_address(__buf_end), std::move(*__p));
		661	__buf.__set_sentinel(++__buf_end);
		662	}
274	swap(__buf);	663	swap(__buf);
275	}	664	}
276	__alloc_traits::construct(__a, std::__to_address(this->__end_), *__first);	665
277	++this->__end_;	666	__alloc_traits::construct(__a, std::__to_address(end()), *__first);
		667	__set_sentinel(size() + 1);
278	}	668	}
279	}	669	}
280	template <class _Tp, class _Allocator>	670
		671	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
281	template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >	672	template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> >
282	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	673	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
283	__split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) {	674	__split_buffer<_Tp, _Allocator, _Layout>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last) {
284	__construct_at_end_with_size(__first, std::distance(__first, __last));	675	__construct_at_end_with_size(__first, std::distance(__first, __last));
285	}	676	}
286		677
287	template <class _Tp, class _Allocator>	678	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
288	template <class _ForwardIterator>	679	template <class _ForwardIterator>
289	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	680	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
290	__split_buffer<_Tp, _Allocator>::__construct_at_end_with_size(_ForwardIterator __first, size_type __n) {	681	__split_buffer<_Tp, _Allocator, _Layout>::__construct_at_end_with_size(_ForwardIterator __first, size_type __n) {
291	_ConstructTransaction __tx(std::addressof(this->__end_), __n);	682	_ConstructTransaction __tx(this, end(), __n);
292	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__first) {	683	for (; __tx.__pos_ != __tx.__end_; ++__tx.__pos_, (void)++__first) {
293	__alloc_traits::construct(__alloc_, std::__to_address(__tx.__pos_), *__first);	684	__alloc_traits::construct(__get_allocator(), std::__to_address(__tx.__pos_), *__first);
294	}	685	}
295	}	686	}
296		687
297	template <class _Tp, class _Allocator>	688	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
298	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void	689	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
299	__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, false_type) {	690	__split_buffer<_Tp, _Allocator, _Layout>::__destruct_at_begin(pointer __new_begin, false_type) {
300	while (__begin_ != __new_begin)	691	pointer __begin = begin();
301	__alloc_traits::destroy(__alloc_, std::__to_address(__begin_++));	692	// Updating begin at every iteration is unnecessary because destruction can't throw.
		693	while (__begin != __new_begin)
		694	__alloc_traits::destroy(__get_allocator(), std::__to_address(__begin++));
		695	__set_valid_range(__begin, end());
302	}	696	}
303		697
304	template <class _Tp, class _Allocator>	698	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
305	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void	699	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
306	__split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_type) {	700	__split_buffer<_Tp, _Allocator, _Layout>::__destruct_at_begin(pointer __new_begin, true_type) {
307	__begin_ = __new_begin;	701	__set_valid_range(__new_begin, end());
308	}
309
310	template <class _Tp, class _Allocator>
311	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
312	__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT {
313	while (__new_last != __end_)
314	__alloc_traits::destroy(__alloc_, std::__to_address(--__end_));
315	}	702	}
316		703
317	template <class _Tp, class _Allocator>	704	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
318	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void	705	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
319	__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT {	706	__split_buffer<_Tp, _Allocator, _Layout>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT {
320	__end_ = __new_last;	707	pointer __end = end();
		708	// Updating begin at every iteration is unnecessary because destruction can't throw.
		709	while (__new_last != __end)
		710	__alloc_traits::destroy(__get_allocator(), std::__to_address(--__end));
		711	__set_sentinel(__end);
321	}	712	}
322		713
323	template <class _Tp, class _Allocator>	714	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
324	_LIBCPP_CONSTEXPR_SINCE_CXX20	715	_LIBCPP_CONSTEXPR_SINCE_CXX20
325	__split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __start, __alloc_rr& __a)	716	__split_buffer<_Tp, _Allocator, _Layout>::__split_buffer(size_type __cap, size_type __start, allocator_type& __a)
326	: __cap_(nullptr), __alloc_(__a) {	717	: __base_type(__a) {
327	if (__cap == 0) {	718	_LIBCPP_ASSERT_INTERNAL(__cap >= __start, "can't have a start point outside the capacity");
328	__first_ = nullptr;	719	if (__cap > 0) {
329	} else {	720	auto __allocation = std::__allocate_at_least(__get_allocator(), __cap);
330	auto __allocation = std::__allocate_at_least(__alloc_, __cap);	721	__set_data(__allocation.ptr);
331	__first_ = __allocation.ptr;	722	__cap = __allocation.count;
332	__cap = __allocation.count;
333	}	723	}
334	__begin_ = __end_ = __first_ + __start;	724
335	__cap_ = __first_ + __cap;	725	pointer __begin = __front_cap() + __start;
		726	__set_valid_range(__begin, __begin);
		727	__set_capacity(__cap);
336	}	728	}
337		729
338	template <class _Tp, class _Allocator>	730	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
339	_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator>::~__split_buffer() {	731	_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator, _Layout>::~__split_buffer() {
340	clear();	732	clear();
341	if (__first_)	733	if (__front_cap())
342	__alloc_traits::deallocate(__alloc_, __first_, capacity());	734	__alloc_traits::deallocate(__get_allocator(), __front_cap(), capacity());
343	}	735	}
344		736
345	template <class _Tp, class _Allocator>	737	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
346	_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)	738	_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator, _Layout>::__split_buffer(__split_buffer&& __c)
347	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)	739	_NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
348	: __first_(std::move(__c.__first_)),	740	: __base_type(std::move(__c)) {
349	__begin_(std::move(__c.__begin_)),	741	__c.__reset();
350	__end_(std::move(__c.__end_)),
351	__cap_(std::move(__c.__cap_)),
352	__alloc_(std::move(__c.__alloc_)) {
353	__c.__first_ = nullptr;
354	__c.__begin_ = nullptr;
355	__c.__end_ = nullptr;
356	__c.__cap_ = nullptr;
357	}	742	}
358		743
359	template <class _Tp, class _Allocator>	744	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
360	_LIBCPP_CONSTEXPR_SINCE_CXX20	745	_LIBCPP_CONSTEXPR_SINCE_CXX20
361	__split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __alloc_rr& __a)	746	__split_buffer<_Tp, _Allocator, _Layout>::__split_buffer(__split_buffer&& __c, const allocator_type& __a)
362	: __cap_(nullptr), __alloc_(__a) {	747	: __base_type(__a) {
363	if (__a == __c.__alloc_) {	748	if (__a == __c.__get_allocator()) {
364	__first_ = __c.__first_;	749	__set_data(__c.__front_cap());
365	__begin_ = __c.__begin_;	750	__set_valid_range(__c.begin(), __c.end());
366	__end_ = __c.__end_;	751	__set_capacity(__c.capacity());
367	__cap_ = __c.__cap_;	752	__c.__reset();
368	__c.__first_ = nullptr;
369	__c.__begin_ = nullptr;
370	__c.__end_ = nullptr;
371	__c.__cap_ = nullptr;
372	} else {	753	} else {
373	auto __allocation = std::__allocate_at_least(__alloc_, __c.size());	754	auto __allocation = std::__allocate_at_least(__get_allocator(), __c.size());
374	__first_ = __allocation.ptr;	755	__set_data(__allocation.ptr);
375	__begin_ = __end_ = __first_;	756	__set_valid_range(__front_cap(), __front_cap());
376	__cap_ = __first_ + __allocation.count;	757	__set_capacity(__allocation.count);
377	typedef move_iterator<iterator> _Ip;	758	typedef move_iterator<iterator> _Ip;
378	__construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));	759	__construct_at_end(_Ip(__c.begin()), _Ip(__c.end()));
379	}	760	}
380	}	761	}
381		762
382	template <class _Tp, class _Allocator>	763	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
383	_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator>&	764	_LIBCPP_CONSTEXPR_SINCE_CXX20 __split_buffer<_Tp, _Allocator, _Layout>&
384	__split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)	765	__split_buffer<_Tp, _Allocator, _Layout>::operator=(__split_buffer&& __c)
385	_NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&	766	_NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
386	is_nothrow_move_assignable<allocator_type>::value) \|\|	767	is_nothrow_move_assignable<allocator_type>::value) \|\|
387	!__alloc_traits::propagate_on_container_move_assignment::value) {	768	!__alloc_traits::propagate_on_container_move_assignment::value) {
388	clear();	769	clear();
389	shrink_to_fit();	770	shrink_to_fit();
390	__first_ = __c.__first_;	771	__copy_without_alloc(__c);
391	__begin_ = __c.__begin_;
392	__end_ = __c.__end_;
393	__cap_ = __c.__cap_;
394	__move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());	772	__move_assign_alloc(__c, integral_constant<bool, __alloc_traits::propagate_on_container_move_assignment::value>());
395	__c.__first_ = __c.__begin_ = __c.__end_ = __c.__cap_ = nullptr;	773	__c.__reset();
396	return *this;	774	return *this;
397	}	775	}
398		776
399	template <class _Tp, class _Allocator>	777	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
400	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)	778	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator, _Layout>::swap(__split_buffer& __x)
401	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\| __is_nothrow_swappable_v<__alloc_rr>) {	779	_NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value \|\| __is_nothrow_swappable_v<allocator_type>) {
402	std::swap(__first_, __x.__first_);	780	__base_type::swap(__x);
403	std::swap(__begin_, __x.__begin_);
404	std::swap(__end_, __x.__end_);
405	std::swap(__cap_, __x.__cap_);
406	std::__swap_allocator(__alloc_, __x.__alloc_);
407	}	781	}
408		782
409	template <class _Tp, class _Allocator>	783	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
410	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT {	784	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator, _Layout>::shrink_to_fit() _NOEXCEPT {
411	if (capacity() > size()) {	785	if (capacity() > size()) {
412	#if _LIBCPP_HAS_EXCEPTIONS	786	#if _LIBCPP_HAS_EXCEPTIONS
413	try {	787	try {
414	#endif // _LIBCPP_HAS_EXCEPTIONS	788	#endif // _LIBCPP_HAS_EXCEPTIONS
415	__split_buffer<value_type, __alloc_rr&> __t(size(), 0, __alloc_);	789	__split_buffer<value_type, allocator_type, _Layout> __t(size(), 0, __get_allocator());
416	if (__t.capacity() < capacity()) {	790	if (__t.capacity() < capacity()) {
417	__t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));	791	__t.__construct_at_end(move_iterator<pointer>(begin()), move_iterator<pointer>(end()));
418	__t.__end_ = __t.__begin_ + (__end_ - __begin_);	792	__t.__set_sentinel(size());
419	std::swap(__first_, __t.__first_);	793	__swap_without_allocator(__t);
420	std::swap(__begin_, __t.__begin_);
421	std::swap(__end_, __t.__end_);
422	std::swap(__cap_, __t.__cap_);
423	}	794	}
424	#if _LIBCPP_HAS_EXCEPTIONS	795	#if _LIBCPP_HAS_EXCEPTIONS
425	} catch (...) {	796	} catch (...) {
...	@@ -428,55 +799,56 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::shrink_to_fi	...	@@ -428,55 +799,56 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::shrink_to_fi
428	}	799	}
429	}	800	}
430		801
431	template <class _Tp, class _Allocator>	802	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
432	template <class... _Args>	803	template <class... _Args>
433	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::emplace_front(_Args&&... __args) {	804	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator, _Layout>::emplace_front(_Args&&... __args) {
434	if (__begin_ == __first_) {	805	if (__front_spare() == 0) {
435	if (__end_ < __cap_) {	806	pointer __end = end();
436	difference_type __d = __cap_ - __end_;	807	if (__back_spare() > 0) {
		808	// The elements are pressed up against the front of the buffer: we need to move them back a
		809	// little bit to make `emplace_front` have amortised O(1) complexity.
		810	difference_type __d = __back_spare();
437	__d = (__d + 1) / 2;	811	__d = (__d + 1) / 2;
438	__begin_ = std::move_backward(__begin_, __end_, __end_ + __d);	812	auto __new_end = __end + __d;
439	__end_ += __d;	813	__set_valid_range(std::move_backward(begin(), __end, __new_end), __new_end);
440	} else {	814	} else {
441	size_type __c = std::max<size_type>(2 * static_cast<size_type>(__cap_ - __first_), 1);	815	size_type __c = std::max<size_type>(2 * capacity(), 1);
442	__split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc_);	816	__split_buffer<value_type, allocator_type, _Layout> __t(__c, (__c + 3) / 4, __get_allocator());
443	__t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));	817	__t.__construct_at_end(move_iterator<pointer>(begin()), move_iterator<pointer>(__end));
444	std::swap(__first_, __t.__first_);	818	__base_type::__swap_without_allocator(__t);
445	std::swap(__begin_, __t.__begin_);
446	std::swap(__end_, __t.__end_);
447	std::swap(__cap_, __t.__cap_);
448	}	819	}
449	}	820	}
450	__alloc_traits::construct(__alloc_, std::__to_address(__begin_ - 1), std::forward<_Args>(__args)...);	821
451	--__begin_;	822	__alloc_traits::construct(__get_allocator(), std::__to_address(begin() - 1), std::forward<_Args>(__args)...);
		823	__set_valid_range(begin() - 1, size() + 1);
452	}	824	}
453		825
454	template <class _Tp, class _Allocator>	826	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
455	template <class... _Args>	827	template <class... _Args>
456	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args) {	828	_LIBCPP_CONSTEXPR_SINCE_CXX20 void __split_buffer<_Tp, _Allocator, _Layout>::emplace_back(_Args&&... __args) {
457	if (__end_ == __cap_) {	829	pointer __end = end();
458	if (__begin_ > __first_) {	830	if (__back_spare() == 0) {
459	difference_type __d = __begin_ - __first_;	831	if (__front_spare() > 0) {
		832	difference_type __d = __front_spare();
460	__d = (__d + 1) / 2;	833	__d = (__d + 1) / 2;
461	__end_ = std::move(__begin_, __end_, __begin_ - __d);	834	__end = std::move(begin(), __end, begin() - __d);
462	__begin_ -= __d;	835	__set_valid_range(begin() - __d, __end);
463	} else {	836	} else {
464	size_type __c = std::max<size_type>(2 * static_cast<size_type>(__cap_ - __first_), 1);	837	size_type __c = std::max<size_type>(2 * capacity(), 1);
465	__split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc_);	838	__split_buffer<value_type, allocator_type, _Layout> __t(__c, __c / 4, __get_allocator());
466	__t.__construct_at_end(move_iterator<pointer>(__begin_), move_iterator<pointer>(__end_));	839	__t.__construct_at_end(move_iterator<pointer>(begin()), move_iterator<pointer>(__end));
467	std::swap(__first_, __t.__first_);	840	__base_type::__swap_without_allocator(__t);
468	std::swap(__begin_, __t.__begin_);
469	std::swap(__end_, __t.__end_);
470	std::swap(__cap_, __t.__cap_);
471	}	841	}
472	}	842	}
473	__alloc_traits::construct(__alloc_, std::__to_address(__end_), std::forward<_Args>(__args)...);	843
474	++__end_;	844	__alloc_traits::construct(__get_allocator(), std::__to_address(__end), std::forward<_Args>(__args)...);
		845	__set_sentinel(++__end);
475	}	846	}
476		847
477	template <class _Tp, class _Allocator>	848	template <class _Tp, class _Allocator, template <class, class, class> class _Layout>
478	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void	849	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI void
479	swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {	850	swap(__split_buffer<_Tp, _Allocator, _Layout>& __x, __split_buffer<_Tp, _Allocator, _Layout>& __y)
		851	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
480	__x.swap(__y);	852	__x.swap(__y);
481	}	853	}
482		854

lib/libcxx/include/__stop_token/atomic_unique_lock.h+1-1

...	@@ -27,7 +27,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -27,7 +27,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
27	// where State contains a lock bit and might contain other data,	27	// where State contains a lock bit and might contain other data,
28	// and LockedBit is the value of State when the lock bit is set, e.g 1 << 2	28	// and LockedBit is the value of State when the lock bit is set, e.g 1 << 2
29	template <class _State, _State _LockedBit>	29	template <class _State, _State _LockedBit>
30	class _LIBCPP_AVAILABILITY_SYNC __atomic_unique_lock {	30	class __atomic_unique_lock {
31	static_assert(std::__popcount(static_cast<unsigned long long>(_LockedBit)) == 1,	31	static_assert(std::__popcount(static_cast<unsigned long long>(_LockedBit)) == 1,
32	"LockedBit must be an integer where only one bit is set");	32	"LockedBit must be an integer where only one bit is set");
33		33

lib/libcxx/include/__stop_token/stop_callback.h+2-2

...	@@ -34,7 +34,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -34,7 +34,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
34	#if _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS	34	#if _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS
35		35
36	template <class _Callback>	36	template <class _Callback>
37	class _LIBCPP_AVAILABILITY_SYNC stop_callback : private __stop_callback_base {	37	class stop_callback : private __stop_callback_base {
38	static_assert(invocable<_Callback>,	38	static_assert(invocable<_Callback>,
39	"Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "	39	"Mandates: stop_callback is instantiated with an argument for the template parameter Callback that "
40	"satisfies invocable.");	40	"satisfies invocable.");
...	@@ -91,7 +91,7 @@ private:	...	@@ -91,7 +91,7 @@ private:
91	};	91	};
92		92
93	template <class _Callback>	93	template <class _Callback>
94	_LIBCPP_AVAILABILITY_SYNC stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;	94	stop_callback(stop_token, _Callback) -> stop_callback<_Callback>;
95		95
96	#endif // _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS	96	#endif // _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS
97		97

lib/libcxx/include/__stop_token/stop_source.h+1-1

...	@@ -30,7 +30,7 @@ struct nostopstate_t {	...	@@ -30,7 +30,7 @@ struct nostopstate_t {
30		30
31	inline constexpr nostopstate_t nostopstate{};	31	inline constexpr nostopstate_t nostopstate{};
32		32
33	class _LIBCPP_AVAILABILITY_SYNC stop_source {	33	class stop_source {
34	public:	34	public:
35	_LIBCPP_HIDE_FROM_ABI stop_source() : __state_(new __stop_state()) { __state_->__increment_stop_source_counter(); }	35	_LIBCPP_HIDE_FROM_ABI stop_source() : __state_(new __stop_state()) { __state_->__increment_stop_source_counter(); }
36		36

lib/libcxx/include/__stop_token/stop_state.h+4-4

lib/libcxx/include/__stop_token/stop_token.h+1-1

...	@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
22		22
23	#if _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS	23	#if _LIBCPP_STD_VER >= 20 && _LIBCPP_HAS_THREADS
24		24
25	class _LIBCPP_AVAILABILITY_SYNC stop_token {	25	class stop_token {
26	public:	26	public:
27	_LIBCPP_HIDE_FROM_ABI stop_token() noexcept = default;	27	_LIBCPP_HIDE_FROM_ABI stop_token() noexcept = default;
28		28

lib/libcxx/include/__string/char_traits.h+51-31

 @@ -94,16 +94,17 @@ struct char_traits<char> {
   }
   // TODO: Make this _LIBCPP_HIDE_FROM_ABI
-  static inline _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR bool eq(char_type __c1, char_type __c2) _NOEXCEPT {
     return __c1 == __c2;
   }
-  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool lt(char_type __c1, char_type __c2) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+  lt(char_type __c1, char_type __c2) _NOEXCEPT {
     return (unsigned char)__c1 < (unsigned char)__c2;
   }
   // __constexpr_memcmp requires a trivially lexicographically comparable type, but char is not when char is a signed
   // type
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  [[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
   compare(const char_type* __lhs, const char_type* __rhs, size_t __count) _NOEXCEPT {
     if (__libcpp_is_constant_evaluated()) {
 #ifdef _LIBCPP_COMPILER_CLANG_BASED
 @@ -126,11 +127,12 @@ struct char_traits<char> {
     }
   }
-  static inline _LIBCPP_HIDE_FROM_ABI size_t _LIBCPP_CONSTEXPR_SINCE_CXX17 length(const char_type* __s) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI size_t _LIBCPP_CONSTEXPR_SINCE_CXX17
+  length(const char_type* __s) _NOEXCEPT {
     return std::__constexpr_strlen(__s);
   }
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  [[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
   find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
     return std::__constexpr_memchr(__s, __a, __n);
   }
 @@ -154,19 +156,24 @@ struct char_traits<char> {
     return __s;
   }
-  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {
     return eq_int_type(__c, eof()) ? ~eof() : __c;
   }
-  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR char_type
+  to_char_type(int_type __c) _NOEXCEPT {
     return char_type(__c);
   }
-  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type
+  to_int_type(char_type __c) _NOEXCEPT {
     return int_type((unsigned char)__c);
   }
-  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT {
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool
+  eq_int_type(int_type __c1, int_type __c2) _NOEXCEPT {
     return __c1 == __c2;
   }
-  static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT { return int_type(EOF); }
+  [[__nodiscard__]] static inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT {
+    return int_type(EOF);
+  }
 };
 template <class _CharT, class _IntT, _IntT _EOFVal>
 @@ -187,11 +194,11 @@ struct __char_traits_base {
     __lhs = __rhs;
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool eq(char_type __lhs, char_type __rhs) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool eq(char_type __lhs, char_type __rhs) _NOEXCEPT {
     return __lhs == __rhs;
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool lt(char_type __lhs, char_type __rhs) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool lt(char_type __lhs, char_type __rhs) _NOEXCEPT {
     return __lhs < __rhs;
   }
 @@ -213,19 +220,22 @@ struct __char_traits_base {
     return __str;
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR char_type to_char_type(int_type __c) _NOEXCEPT {
     return char_type(__c);
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT { return int_type(__c); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type to_int_type(char_type __c) _NOEXCEPT {
+    return int_type(__c);
+  }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool eq_int_type(int_type __lhs, int_type __rhs) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR bool
+  eq_int_type(int_type __lhs, int_type __rhs) _NOEXCEPT {
     return __lhs == __rhs;
   }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT { return _EOFVal; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type eof() _NOEXCEPT { return _EOFVal; }
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR int_type not_eof(int_type __c) _NOEXCEPT {
     return eq_int_type(__c, eof()) ? static_cast<int_type>(~eof()) : __c;
   }
 };
 @@ -235,18 +245,19 @@ struct __char_traits_base {
 #if _LIBCPP_HAS_WIDE_CHARACTERS
 template <>
 struct char_traits<wchar_t> : __char_traits_base<wchar_t, wint_t, static_cast<wint_t>(WEOF)> {
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  [[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 int
   compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
     if (__n == 0)
       return 0;
     return std::__constexpr_wmemcmp(__s1, __s2, __n);
   }
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t length(const char_type* __s) _NOEXCEPT {
+  [[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t
+  length(const char_type* __s) _NOEXCEPT {
     return std::__constexpr_wcslen(__s);
   }
-  static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  [[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
   find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
     return std::__constexpr_wmemchr(__s, __a, __n);
   }
 @@ -257,16 +268,16 @@ struct char_traits<wchar_t> : __char_traits_base<wchar_t, wint_t, static_cast<wi
 template <>
 struct char_traits<char8_t> : __char_traits_base<char8_t, unsigned int, static_cast<unsigned int>(EOF)> {
-  static _LIBCPP_HIDE_FROM_ABI constexpr int
+  [[nodiscard]] static _LIBCPP_HIDE_FROM_ABI constexpr int
   compare(const char_type* __s1, const char_type* __s2, size_t __n) noexcept {
     return std::__constexpr_memcmp(__s1, __s2, __element_count(__n));
   }
-  static _LIBCPP_HIDE_FROM_ABI constexpr size_t length(const char_type* __str) noexcept {
+  [[nodiscard]] static _LIBCPP_HIDE_FROM_ABI constexpr size_t length(const char_type* __str) noexcept {
     return std::__constexpr_strlen(__str);
   }
-  _LIBCPP_HIDE_FROM_ABI static constexpr const char_type*
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr const char_type*
   find(const char_type* __s, size_t __n, const char_type& __a) noexcept {
     return std::__constexpr_memchr(__s, __a, __n);
   }
 @@ -276,11 +287,11 @@ struct char_traits<char8_t> : __char_traits_base<char8_t, unsigned int, static_c
 template <>
 struct char_traits<char16_t> : __char_traits_base<char16_t, uint_least16_t, static_cast<uint_least16_t>(0xFFFF)> {
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 int
   compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t length(const char_type* __s) _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
   find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
     __identity __proj;
     const char_type* __match = std::__find(__s, __s + __n, __a, __proj);
 @@ -290,7 +301,7 @@ struct char_traits<char16_t> : __char_traits_base<char16_t, uint_least16_t, stat
   }
 };
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 int
 char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
   for (; __n; --__n, ++__s1, ++__s2) {
     if (lt(*__s1, *__s2))
 @@ -301,7 +312,8 @@ char_traits<char16_t>::compare(const char_type* __s1, const char_type* __s2, siz
   return 0;
 }
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t
+char_traits<char16_t>::length(const char_type* __s) _NOEXCEPT {
   size_t __len = 0;
   for (; !eq(*__s, char_type(0)); ++__s)
     ++__len;
 @@ -310,11 +322,11 @@ inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t char_traits<char16_t>::length(const
 template <>
 struct char_traits<char32_t> : __char_traits_base<char32_t, uint_least32_t, static_cast<uint_least32_t>(0xFFFFFFFF)> {
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 int
   compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t length(const char_type* __s) _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX17 const char_type*
   find(const char_type* __s, size_t __n, const char_type& __a) _NOEXCEPT {
     __identity __proj;
     const char_type* __match = std::__find(__s, __s + __n, __a, __proj);
 @@ -324,7 +336,7 @@ struct char_traits<char32_t> : __char_traits_base<char32_t, uint_least32_t, stat
   }
 };
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17 int
+[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 int
 char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, size_t __n) _NOEXCEPT {
   for (; __n; --__n, ++__s1, ++__s2) {
     if (lt(*__s1, *__s2))
 @@ -335,7 +347,8 @@ char_traits<char32_t>::compare(const char_type* __s1, const char_type* __s2, siz
   return 0;
 }
-inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_CONSTEXPR_SINCE_CXX17 size_t
+char_traits<char32_t>::length(const char_type* __s) _NOEXCEPT {
   size_t __len = 0;
   for (; !eq(*__s, char_type(0)); ++__s)
     ++__len;
 @@ -369,6 +382,13 @@ _LIBCPP_HIDE_FROM_ABI inline _LIBCPP_CONSTEXPR_SINCE_CXX14 const _CharT* __searc
   if (__len1 < __len2)
     return __last1;
+  if (__builtin_constant_p(__len2 == 1) && __len2 == 1) {
+    auto __res = _Traits::find(__first1, __len1, *__first2);
+    if (__res == nullptr)
+      return __last1;
+    return __res;
+  }
   // First element of __first2 is loop invariant.
   _CharT __f2 = *__first2;
   while (true) {

lib/libcxx/include/__string/constexpr_c_functions.h+5-5

 @@ -22,7 +22,6 @@
 #include <__type_traits/is_equality_comparable.h>
 #include <__type_traits/is_integral.h>
 #include <__type_traits/is_same.h>
-#include <__type_traits/is_trivially_copyable.h>
 #include <__type_traits/is_trivially_lexicographically_comparable.h>
 #include <__type_traits/remove_cv.h>
 #include <__utility/element_count.h>
 @@ -96,14 +95,13 @@ __constexpr_memcmp(const _Tp* __lhs, const _Up* __rhs, __element_count __n) {
   }
 }
-// Because of __libcpp_is_trivially_equality_comparable we know that comparing the object representations is equivalent
+// Because of __is_trivially_equality_comparable_v we know that comparing the object representations is equivalent
 // to a std::memcmp(...) == 0. Since we have multiple objects contiguously in memory, we can call memcmp once instead
 // of invoking it on every object individually.
 template <class _Tp, class _Up>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
 __constexpr_memcmp_equal(const _Tp* __lhs, const _Up* __rhs, __element_count __n) {
-  static_assert(__libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
+  static_assert(__is_trivially_equality_comparable_v<_Tp, _Up>, "_Tp and _Up have to be trivially equality comparable");
-                "_Tp and _Up have to be trivially equality comparable");
   auto __count = static_cast<size_t>(__n);
 @@ -128,7 +126,7 @@ __constexpr_memcmp_equal(const _Tp* __lhs, const _Up* __rhs, __element_count __n
 template <class _Tp, class _Up>
 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __constexpr_memchr(_Tp* __str, _Up __value, size_t __count) {
-  static_assert(sizeof(_Tp) == 1 && __libcpp_is_trivially_equality_comparable<_Tp, _Up>::value,
+  static_assert(sizeof(_Tp) == 1 && __is_trivially_equality_comparable_v<_Tp, _Up>,
                 "Calling memchr on non-trivially equality comparable types is unsafe.");
   if (__libcpp_is_constant_evaluated()) {
 @@ -225,6 +223,8 @@ __constexpr_memmove(_Tp* __dest, _Up* __src, __element_count __n) {
           std::__assign_trivially_copyable(__dest[__i], __src[__i]);
       }
     }
+  } else if _LIBCPP_CONSTEXPR (sizeof(_Tp) == __datasizeof_v<_Tp>) {
+    ::__builtin_memmove(__dest, __src, __count * sizeof(_Tp));
   } else if (__count > 0) {
     ::__builtin_memmove(__dest, __src, (__count - 1) * sizeof(_Tp) + __datasizeof_v<_Tp>);
   }

lib/libcxx/include/__support/xlocale/__strtonum_fallback.h-8

...	@@ -34,12 +34,4 @@ inline _LIBCPP_HIDE_FROM_ABI long double strtold_l(const char* __nptr, char** __	...	@@ -34,12 +34,4 @@ inline _LIBCPP_HIDE_FROM_ABI long double strtold_l(const char* __nptr, char** __
34	return ::strtold(__nptr, __endptr);	34	return ::strtold(__nptr, __endptr);
35	}	35	}
36		36
37	inline _LIBCPP_HIDE_FROM_ABI long long strtoll_l(const char* __nptr, char** __endptr, int __base, locale_t) {
38	return ::strtoll(__nptr, __endptr, __base);
39	}
40
41	inline _LIBCPP_HIDE_FROM_ABI unsigned long long strtoull_l(const char* __nptr, char** __endptr, int __base, locale_t) {
42	return ::strtoull(__nptr, __endptr, __base);
43	}
44
45	#endif // _LIBCPP___SUPPORT_XLOCALE_STRTONUM_FALLBACK_H	37	#endif // _LIBCPP___SUPPORT_XLOCALE_STRTONUM_FALLBACK_H

lib/libcxx/include/__system_error/error_category.h+8-8

lib/libcxx/include/__system_error/error_code.h+5-5

...	@@ -71,20 +71,20 @@ public:	...	@@ -71,20 +71,20 @@ public:
71	__cat_ = &system_category();	71	__cat_ = &system_category();
72	}	72	}
73		73
74	_LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }	74	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
75		75
76	_LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }	76	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
77		77
78	_LIBCPP_HIDE_FROM_ABI error_condition default_error_condition() const _NOEXCEPT {	78	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI error_condition default_error_condition() const _NOEXCEPT {
79	return __cat_->default_error_condition(__val_);	79	return __cat_->default_error_condition(__val_);
80	}	80	}
81		81
82	string message() const;	82	[[__nodiscard__]] string message() const;
83		83
84	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }	84	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
85	};	85	};
86		86
87	inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(errc __e) _NOEXCEPT {	87	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(errc __e) _NOEXCEPT {
88	return error_code(static_cast<int>(__e), generic_category());	88	return error_code(static_cast<int>(__e), generic_category());
89	}	89	}
90		90

lib/libcxx/include/__system_error/error_condition.h+4-4

...	@@ -80,15 +80,15 @@ public:	...	@@ -80,15 +80,15 @@ public:
80	__cat_ = &generic_category();	80	__cat_ = &generic_category();
81	}	81	}
82		82
83	_LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }	83	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int value() const _NOEXCEPT { return __val_; }
84		84
85	_LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }	85	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const error_category& category() const _NOEXCEPT { return *__cat_; }
86	string message() const;	86	[[__nodiscard__]] string message() const;
87		87
88	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }	88	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return __val_ != 0; }
89	};	89	};
90		90
91	inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(errc __e) _NOEXCEPT {	91	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(errc __e) _NOEXCEPT {
92	return error_condition(static_cast<int>(__e), generic_category());	92	return error_condition(static_cast<int>(__e), generic_category());
93	}	93	}
94		94

lib/libcxx/include/__system_error/system_error.h+1-1

...	@@ -36,7 +36,7 @@ public:	...	@@ -36,7 +36,7 @@ public:
36	_LIBCPP_HIDE_FROM_ABI system_error(const system_error&) _NOEXCEPT = default;	36	_LIBCPP_HIDE_FROM_ABI system_error(const system_error&) _NOEXCEPT = default;
37	~system_error() _NOEXCEPT override;	37	~system_error() _NOEXCEPT override;
38		38
39	_LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }	39	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
40	};	40	};
41		41
42	// __ev is expected to be an error in the generic_category domain (e.g. from	42	// __ev is expected to be an error in the generic_category domain (e.g. from

lib/libcxx/include/__thread/id.h+1-1

...	@@ -23,7 +23,7 @@	...	@@ -23,7 +23,7 @@
23	_LIBCPP_BEGIN_NAMESPACE_STD	23	_LIBCPP_BEGIN_NAMESPACE_STD
24		24
25	#if _LIBCPP_HAS_THREADS	25	#if _LIBCPP_HAS_THREADS
26	class _LIBCPP_EXPORTED_FROM_ABI __thread_id;	26	class __thread_id;
27		27
28	namespace this_thread {	28	namespace this_thread {
29		29

lib/libcxx/include/__thread/jthread.h+1-1

...	@@ -36,7 +36,7 @@ _LIBCPP_PUSH_MACROS	...	@@ -36,7 +36,7 @@ _LIBCPP_PUSH_MACROS
36		36
37	_LIBCPP_BEGIN_NAMESPACE_STD	37	_LIBCPP_BEGIN_NAMESPACE_STD
38		38
39	class _LIBCPP_AVAILABILITY_SYNC jthread {	39	class jthread {
40	public:	40	public:
41	// types	41	// types
42	using id = thread::id;	42	using id = thread::id;

lib/libcxx/include/__thread/poll_with_backoff.h+27-8

 @@ -22,33 +22,50 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 static _LIBCPP_CONSTEXPR const int __libcpp_polling_count = 64;
+enum class __backoff_results : unsigned char {
+  __continue_poll   = 1,
+  __poll_success    = 2,
+  __timeout         = 3,
+  __backoff_failure = 4,
+};
+enum class __poll_with_backoff_results : unsigned char {
+  __poll_success    = static_cast<unsigned char>(__backoff_results::__poll_success),
+  __timeout         = static_cast<unsigned char>(__backoff_results::__timeout),
+  __backoff_failure = static_cast<unsigned char>(__backoff_results::__backoff_failure),
+};
 // Polls a thread for a condition given by a predicate, and backs off based on a backoff policy
 // before polling again.
 //
 // - __poll is the "test function" that should return true if polling succeeded, and false if it failed.
 //
 // - __backoff is the "backoff policy", which is called with the duration since we started polling. It should
-//   return false in order to resume polling, and true if polling should stop entirely for some reason.
+//   return  __backoff_results::__continue_poll in order to resume polling, and other appropriate  __backoff_results
+//   if polling should stop entirely for some reason.
 //   In general, backoff policies sleep for some time before returning control to the polling loop.
 //
 // - __max_elapsed is the maximum duration to try polling for. If the maximum duration is exceeded,
-//   the polling loop will return false to report a timeout.
+//   the polling loop will return __poll_with_backoff_results::__timeout to report a timeout.
 template <class _Poll, class _Backoff>
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_poll_with_backoff(
+_LIBCPP_HIDE_FROM_ABI __poll_with_backoff_results __libcpp_thread_poll_with_backoff(
     _Poll&& __poll, _Backoff&& __backoff, chrono::nanoseconds __max_elapsed = chrono::nanoseconds::zero()) {
   auto const __start = chrono::high_resolution_clock::now();
   for (int __count = 0;;) {
     if (__poll())
-      return true; // __poll completion means success
+      return __poll_with_backoff_results::__poll_success;
     if (__count < __libcpp_polling_count) {
       __count += 1;
       continue;
     }
     chrono::nanoseconds const __elapsed = chrono::high_resolution_clock::now() - __start;
     if (__max_elapsed != chrono::nanoseconds::zero() && __max_elapsed < __elapsed)
-      return false; // timeout failure
+      return __poll_with_backoff_results::__timeout;
-    if (__backoff(__elapsed))
+    if (auto __backoff_res = __backoff(__elapsed); __backoff_res == __backoff_results::__continue_poll)
-      return false; // __backoff completion means failure
+      continue;
+    else
+      return static_cast<__poll_with_backoff_results>(__backoff_res);
   }
 }
 @@ -59,7 +76,9 @@ _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __libcpp_thread_poll_with_b
 // so this should most likely only be used on single-threaded systems where there
 // are no other threads to compete with.
 struct __spinning_backoff_policy {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator()(chrono::nanoseconds const&) const { return false; }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __backoff_results operator()(chrono::nanoseconds const&) const {
+    return __backoff_results::__continue_poll;
+  }
 };
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__thread/support/c11.h+8-8

lib/libcxx/include/__thread/support/pthread.h+8-8

lib/libcxx/include/__thread/support/windows.h+8-8

lib/libcxx/include/__thread/thread.h+13-8

 @@ -25,6 +25,8 @@
 #include <__thread/support.h>
 #include <__type_traits/decay.h>
 #include <__type_traits/enable_if.h>
+#include <__type_traits/invoke.h>
+#include <__type_traits/is_constructible.h>
 #include <__type_traits/is_same.h>
 #include <__type_traits/remove_cvref.h>
 #include <__utility/forward.h>
 @@ -155,8 +157,8 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, __thread_id __id) {
 #  ifndef _LIBCPP_CXX03_LANG
 template <class _TSp, class _Fp, class... _Args, size_t... _Indices>
-inline _LIBCPP_HIDE_FROM_ABI void __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __tuple_indices<_Indices...>) {
+inline _LIBCPP_HIDE_FROM_ABI void __thread_execute(tuple<_TSp, _Fp, _Args...>& __t, __index_sequence<_Indices...>) {
-  std::__invoke(std::move(std::get<1>(__t)), std::move(std::get<_Indices>(__t))...);
+  std::__invoke(std::move(std::get<_Indices + 1>(__t))...);
 }
 template <class _Fp>
 @@ -164,8 +166,7 @@ _LIBCPP_HIDE_FROM_ABI void* __thread_proxy(void* __vp) {
   // _Fp = tuple< unique_ptr<__thread_struct>, Functor, Args...>
   unique_ptr<_Fp> __p(static_cast<_Fp*>(__vp));
   __thread_local_data().set_pointer(std::get<0>(*__p.get()).release());
-  typedef typename __make_tuple_indices<tuple_size<_Fp>::value, 2>::type _Index;
+  std::__thread_execute(*__p.get(), __make_index_sequence<tuple_size<_Fp>::value - 1>());
-  std::__thread_execute(*__p.get(), _Index());
   return nullptr;
 }
 @@ -206,6 +207,10 @@ public:
 #  ifndef _LIBCPP_CXX03_LANG
   template <class _Fp, class... _Args, __enable_if_t<!is_same<__remove_cvref_t<_Fp>, thread>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI explicit thread(_Fp&& __f, _Args&&... __args) {
+    static_assert(is_constructible<__decay_t<_Fp>, _Fp>::value, "");
+    static_assert(_And<is_constructible<__decay_t<_Args>, _Args>...>::value, "");
+    static_assert(__is_invocable_v<__decay_t<_Fp>, __decay_t<_Args>...>, "");
     typedef unique_ptr<__thread_struct> _TSPtr;
     _TSPtr __tsp(new __thread_struct);
     typedef tuple<_TSPtr, __decay_t<_Fp>, __decay_t<_Args>...> _Gp;
 @@ -243,13 +248,13 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(thread& __t) _NOEXCEPT { std::swap(__t_, __t.__t_); }
-  _LIBCPP_HIDE_FROM_ABI bool joinable() const _NOEXCEPT { return !__libcpp_thread_isnull(&__t_); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool joinable() const _NOEXCEPT { return !__libcpp_thread_isnull(&__t_); }
   void join();
   void detach();
-  _LIBCPP_HIDE_FROM_ABI id get_id() const _NOEXCEPT { return __libcpp_thread_get_id(&__t_); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI id get_id() const _NOEXCEPT { return __libcpp_thread_get_id(&__t_); }
-  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() _NOEXCEPT { return __t_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() _NOEXCEPT { return __t_; }
-  static unsigned hardware_concurrency() _NOEXCEPT;
+  [[__nodiscard__]] static unsigned hardware_concurrency() _NOEXCEPT;
 };
 inline _LIBCPP_HIDE_FROM_ABI void swap(thread& __x, thread& __y) _NOEXCEPT { __x.swap(__y); }

lib/libcxx/include/__thread/timed_backoff_policy.h+3-2

...	@@ -11,6 +11,7 @@	...	@@ -11,6 +11,7 @@
11	#define _LIBCPP___THREAD_TIMED_BACKOFF_POLICY_H	11	#define _LIBCPP___THREAD_TIMED_BACKOFF_POLICY_H
12		12
13	#include <__config>	13	#include <__config>
		14	#include <__thread/poll_with_backoff.h>
14		15
15	#if _LIBCPP_HAS_THREADS	16	#if _LIBCPP_HAS_THREADS
16		17
...	@@ -24,7 +25,7 @@	...	@@ -24,7 +25,7 @@
24	_LIBCPP_BEGIN_NAMESPACE_STD	25	_LIBCPP_BEGIN_NAMESPACE_STD
25		26
26	struct __libcpp_timed_backoff_policy {	27	struct __libcpp_timed_backoff_policy {
27	_LIBCPP_HIDE_FROM_ABI bool operator()(chrono::nanoseconds __elapsed) const {	28	_LIBCPP_HIDE_FROM_ABI __backoff_results operator()(chrono::nanoseconds __elapsed) const {
28	if (__elapsed > chrono::milliseconds(128))	29	if (__elapsed > chrono::milliseconds(128))
29	__libcpp_thread_sleep_for(chrono::milliseconds(8));	30	__libcpp_thread_sleep_for(chrono::milliseconds(8));
30	else if (__elapsed > chrono::microseconds(64))	31	else if (__elapsed > chrono::microseconds(64))
...	@@ -33,7 +34,7 @@ struct __libcpp_timed_backoff_policy {	...	@@ -33,7 +34,7 @@ struct __libcpp_timed_backoff_policy {
33	__libcpp_thread_yield();	34	__libcpp_thread_yield();
34	else {	35	else {
35	} // poll	36	} // poll
36	return false;	37	return __backoff_results::__continue_poll;
37	}	38	}
38	};	39	};
39		40

lib/libcxx/include/__tree+849-701

...	@@ -11,37 +11,39 @@	...	@@ -11,37 +11,39 @@
11	#define _LIBCPP___TREE	11	#define _LIBCPP___TREE
12		12
13	#include <__algorithm/min.h>	13	#include <__algorithm/min.h>
		14	#include <__algorithm/specialized_algorithms.h>
14	#include <__assert>	15	#include <__assert>
15	#include <__config>	16	#include <__config>
16	#include <__fwd/map.h>
17	#include <__fwd/pair.h>	17	#include <__fwd/pair.h>
18	#include <__fwd/set.h>
19	#include <__iterator/distance.h>	18	#include <__iterator/distance.h>
20	#include <__iterator/iterator_traits.h>	19	#include <__iterator/iterator_traits.h>
21	#include <__iterator/next.h>	20	#include <__iterator/next.h>
22	#include <__memory/addressof.h>	21	#include <__memory/addressof.h>
23	#include <__memory/allocator_traits.h>	22	#include <__memory/allocator_traits.h>
24	#include <__memory/compressed_pair.h>	23	#include <__memory/compressed_pair.h>
		24	#include <__memory/construct_at.h>
25	#include <__memory/pointer_traits.h>	25	#include <__memory/pointer_traits.h>
26	#include <__memory/swap_allocator.h>	26	#include <__memory/swap_allocator.h>
27	#include <__memory/unique_ptr.h>	27	#include <__memory/unique_ptr.h>
28	#include <__type_traits/can_extract_key.h>	28	#include <__new/launder.h>
29	#include <__type_traits/copy_cvref.h>	29	#include <__type_traits/copy_cvref.h>
30	#include <__type_traits/enable_if.h>	30	#include <__type_traits/enable_if.h>
31	#include <__type_traits/invoke.h>	31	#include <__type_traits/invoke.h>
32	#include <__type_traits/is_const.h>
33	#include <__type_traits/is_constructible.h>	32	#include <__type_traits/is_constructible.h>
34	#include <__type_traits/is_nothrow_assignable.h>	33	#include <__type_traits/is_nothrow_assignable.h>
35	#include <__type_traits/is_nothrow_constructible.h>	34	#include <__type_traits/is_nothrow_constructible.h>
36	#include <__type_traits/is_same.h>	35	#include <__type_traits/is_same.h>
		36	#include <__type_traits/is_specialization.h>
37	#include <__type_traits/is_swappable.h>	37	#include <__type_traits/is_swappable.h>
		38	#include <__type_traits/make_transparent.h>
38	#include <__type_traits/remove_const.h>	39	#include <__type_traits/remove_const.h>
39	#include <__type_traits/remove_const_ref.h>
40	#include <__type_traits/remove_cvref.h>	40	#include <__type_traits/remove_cvref.h>
41	#include <__utility/forward.h>	41	#include <__utility/forward.h>
		42	#include <__utility/lazy_synth_three_way_comparator.h>
42	#include <__utility/move.h>	43	#include <__utility/move.h>
43	#include <__utility/pair.h>	44	#include <__utility/pair.h>
44	#include <__utility/swap.h>	45	#include <__utility/swap.h>
		46	#include <__utility/try_key_extraction.h>
45	#include <limits>	47	#include <limits>
46		48
47	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	49	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
...	@@ -51,14 +53,31 @@	...	@@ -51,14 +53,31 @@
51	_LIBCPP_PUSH_MACROS	53	_LIBCPP_PUSH_MACROS
52	#include <__undef_macros>	54	#include <__undef_macros>
53		55
54	_LIBCPP_BEGIN_NAMESPACE_STD	56	_LIBCPP_DIAGNOSTIC_PUSH
		57	// GCC complains about the backslashes at the end, see https://gcc.gnu.org/bugzilla/show_bug.cgi?id=121528
		58	_LIBCPP_GCC_DIAGNOSTIC_IGNORED("-Wcomment")
		59	// __tree is a red-black-tree implementation used for the associative containers (i.e. (multi)map/set). It stores
		60	// - (1) a pointer to the node with the smallest (i.e. leftmost) element, namely __begin_node_
		61	// - (2) the number of nodes in the tree, namely __size_
		62	// - (3) a pointer to the root of the tree, namely __end_node_
		63	//
		64	// Storing (1) and (2) is required to allow for constant time lookups. A tree looks like this in memory:
		65	//
		66	// __end_node_
		67	// \|
		68	// root
		69	// / \
		70	// l1 r1
		71	// / \ / \
		72	// ... ... ... ...
		73	//
		74	// All nodes except __end_node_ have a __left_ and __right_ pointer as well as a __parent_ pointer.
		75	// __end_node_ only contains a __left_ pointer, which points to the root of the tree.
		76	// This layout allows for iteration through the tree without a need for special handling of the end node. See
		77	// __tree_next_iter and __tree_prev_iter for more details.
		78	_LIBCPP_DIAGNOSTIC_POP
55		79
56	template <class _Tp, class _Compare, class _Allocator>	80	_LIBCPP_BEGIN_NAMESPACE_STD
57	class __tree;
58	template <class _Tp, class _NodePtr, class _DiffType>
59	class __tree_iterator;
60	template <class _Tp, class _ConstNodePtr, class _DiffType>
61	class __tree_const_iterator;
62		81
63	template <class _Pointer>	82	template <class _Pointer>
64	class __tree_end_node;	83	class __tree_end_node;
...	@@ -70,13 +89,6 @@ class __tree_node;	...	@@ -70,13 +89,6 @@ class __tree_node;
70	template <class _Key, class _Value>	89	template <class _Key, class _Value>
71	struct __value_type;	90	struct __value_type;
72		91
73	template <class _Allocator>
74	class __map_node_destructor;
75	template <class _TreeIterator>
76	class __map_iterator;
77	template <class _TreeIterator>
78	class __map_const_iterator;
79
80	/*	92	/*
81		93
82	_NodePtr algorithms	94	_NodePtr algorithms
...	@@ -185,6 +197,11 @@ _LIBCPP_HIDE_FROM_ABI _NodePtr __tree_next(_NodePtr __x) _NOEXCEPT {	...	@@ -185,6 +197,11 @@ _LIBCPP_HIDE_FROM_ABI _NodePtr __tree_next(_NodePtr __x) _NOEXCEPT {
185	return __x->__parent_unsafe();	197	return __x->__parent_unsafe();
186	}	198	}
187		199
		200	// __tree_next_iter and __tree_prev_iter implement iteration through the tree. The order is as follows:
		201	// left sub-tree -> node -> right sub-tree. When the right-most node of a sub-tree is reached, we walk up the tree until
		202	// we find a node where we were in the left sub-tree. We are _always_ in a left sub-tree, since the __end_node_ points
		203	// to the actual root of the tree through a __left_ pointer. Incrementing the end() pointer is UB, so we can assume that
		204	// never happens.
188	template <class _EndNodePtr, class _NodePtr>	205	template <class _EndNodePtr, class _NodePtr>
189	inline _LIBCPP_HIDE_FROM_ABI _EndNodePtr __tree_next_iter(_NodePtr __x) _NOEXCEPT {	206	inline _LIBCPP_HIDE_FROM_ABI _EndNodePtr __tree_next_iter(_NodePtr __x) _NOEXCEPT {
190	_LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");	207	_LIBCPP_ASSERT_INTERNAL(__x != nullptr, "node shouldn't be null");
...	@@ -494,16 +511,7 @@ _LIBCPP_HIDE_FROM_ABI void __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEP	...	@@ -494,16 +511,7 @@ _LIBCPP_HIDE_FROM_ABI void __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEP
494	// node traits	511	// node traits
495		512
496	template <class _Tp>	513	template <class _Tp>
497	struct __is_tree_value_type_imp : false_type {};	514	inline const bool __is_tree_value_type_v = __is_specialization_v<_Tp, __value_type>;
498
499	template <class _Key, class _Value>
500	struct __is_tree_value_type_imp<__value_type<_Key, _Value> > : true_type {};
501
502	template <class... _Args>
503	struct __is_tree_value_type : false_type {};
504
505	template <class _One>
506	struct __is_tree_value_type<_One> : __is_tree_value_type_imp<__remove_cvref_t<_One> > {};
507		515
508	template <class _Tp>	516	template <class _Tp>
509	struct __get_tree_key_type {	517	struct __get_tree_key_type {
...	@@ -549,15 +557,14 @@ private:	...	@@ -549,15 +557,14 @@ private:
549	template <class _Pointer>	557	template <class _Pointer>
550	class __tree_end_node {	558	class __tree_end_node {
551	public:	559	public:
552	typedef _Pointer pointer;	560	using pointer = _Pointer;
553	pointer __left_;	561	pointer __left_;
554		562
555	_LIBCPP_HIDE_FROM_ABI __tree_end_node() _NOEXCEPT : __left_() {}	563	_LIBCPP_HIDE_FROM_ABI __tree_end_node() _NOEXCEPT : __left_() {}
556	};	564	};
557		565
558	template <class _VoidPtr>	566	template <class _VoidPtr>
559	class _LIBCPP_STANDALONE_DEBUG	567	class __tree_node_base : public __tree_end_node<__rebind_pointer_t<_VoidPtr, __tree_node_base<_VoidPtr> > > {
560	__tree_node_base : public __tree_end_node<__rebind_pointer_t<_VoidPtr, __tree_node_base<_VoidPtr> > > {
561	public:	568	public:
562	using pointer = __rebind_pointer_t<_VoidPtr, __tree_node_base>;	569	using pointer = __rebind_pointer_t<_VoidPtr, __tree_node_base>;
563	using __end_node_pointer _LIBCPP_NODEBUG = __rebind_pointer_t<_VoidPtr, __tree_end_node<pointer> >;	570	using __end_node_pointer _LIBCPP_NODEBUG = __rebind_pointer_t<_VoidPtr, __tree_end_node<pointer> >;
...	@@ -570,20 +577,41 @@ public:	...	@@ -570,20 +577,41 @@ public:
570		577
571	_LIBCPP_HIDE_FROM_ABI void __set_parent(pointer __p) { __parent_ = static_cast<__end_node_pointer>(__p); }	578	_LIBCPP_HIDE_FROM_ABI void __set_parent(pointer __p) { __parent_ = static_cast<__end_node_pointer>(__p); }
572		579
573	~__tree_node_base() = delete;	580	_LIBCPP_HIDE_FROM_ABI __tree_node_base() = default;
574	__tree_node_base(__tree_node_base const&) = delete;	581	__tree_node_base(__tree_node_base const&) = delete;
575	__tree_node_base& operator=(__tree_node_base const&) = delete;	582	__tree_node_base& operator=(__tree_node_base const&) = delete;
576	};	583	};
577		584
578	template <class _Tp, class _VoidPtr>	585	template <class _Tp, class _VoidPtr>
579	class _LIBCPP_STANDALONE_DEBUG __tree_node : public __tree_node_base<_VoidPtr> {	586	class __tree_node : public __tree_node_base<_VoidPtr> {
580	public:	587	public:
581	using __node_value_type _LIBCPP_NODEBUG = __get_node_value_type_t<_Tp>;	588	using __node_value_type _LIBCPP_NODEBUG = __get_node_value_type_t<_Tp>;
582		589
583	__node_value_type __value_;	590	// We use a union to avoid initialization during member initialization, which allows us
		591	// to use the allocator from the container to construct the `__node_value_type` in the
		592	// memory provided by the union member
		593	#ifndef _LIBCPP_CXX03_LANG
		594
		595	private:
		596	union {
		597	__node_value_type __value_;
		598	};
584		599
		600	public:
585	_LIBCPP_HIDE_FROM_ABI __node_value_type& __get_value() { return __value_; }	601	_LIBCPP_HIDE_FROM_ABI __node_value_type& __get_value() { return __value_; }
		602	#else
		603
		604	private:
		605	_ALIGNAS_TYPE(__node_value_type) unsigned char __buffer_[sizeof(__node_value_type)];
		606
		607	public:
		608	_LIBCPP_HIDE_FROM_ABI __node_value_type& __get_value() { return reinterpret_cast<__node_value_type>(__buffer_); }
		609	#endif
586		610
		611	template <class _Alloc, class... _Args>
		612	_LIBCPP_HIDE_FROM_ABI explicit __tree_node(_Alloc& __na, _Args&&... __args) {
		613	allocator_traits<_Alloc>::construct(__na, std::addressof(__get_value()), std::forward<_Args>(__args)...);
		614	}
587	~__tree_node() = delete;	615	~__tree_node() = delete;
588	__tree_node(__tree_node const&) = delete;	616	__tree_node(__tree_node const&) = delete;
589	__tree_node& operator=(__tree_node const&) = delete;	617	__tree_node& operator=(__tree_node const&) = delete;
...	@@ -591,11 +619,11 @@ public:	...	@@ -591,11 +619,11 @@ public:
591		619
592	template <class _Allocator>	620	template <class _Allocator>
593	class __tree_node_destructor {	621	class __tree_node_destructor {
594	typedef _Allocator allocator_type;	622	using allocator_type = _Allocator;
595	typedef allocator_traits<allocator_type> __alloc_traits;	623	using __alloc_traits _LIBCPP_NODEBUG = allocator_traits<allocator_type>;
596		624
597	public:	625	public:
598	typedef typename __alloc_traits::pointer pointer;	626	using pointer = typename __alloc_traits::pointer;
599		627
600	private:	628	private:
601	allocator_type& __na_;	629	allocator_type& __na_;
...	@@ -612,7 +640,7 @@ public:	...	@@ -612,7 +640,7 @@ public:
612		640
613	_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {	641	_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
614	if (__value_constructed)	642	if (__value_constructed)
615	__alloc_traits::destroy(__na_, std::addressof(__p->__value_));	643	__alloc_traits::destroy(__na_, std::addressof(__p->__get_value()));
616	if (__p)	644	if (__p)
617	__alloc_traits::deallocate(__na_, __p, 1);	645	__alloc_traits::deallocate(__na_, __p, 1);
618	}	646	}
...	@@ -630,12 +658,60 @@ struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc> :	...	@@ -630,12 +658,60 @@ struct __generic_container_node_destructor<__tree_node<_Tp, _VoidPtr>, _Alloc> :
630	};	658	};
631	#endif	659	#endif
632		660
		661	// Do an in-order traversal of the tree until `__break` returns true. Takes the root node of the tree.
		662	template <class _Reference, class _Break, class _NodePtr, class _Func, class _Proj>
		663	#ifndef _LIBCPP_COMPILER_GCC // This function is recursive, so GCC complains about always_inline.
		664	_LIBCPP_HIDE_FROM_ABI
		665	#endif
		666	bool __tree_iterate_from_root(_Break __break, _NodePtr __root, _Func& __func, _Proj& __proj) {
		667	if (__root->__left_) {
		668	if (std::__tree_iterate_from_root<_Reference>(__break, static_cast<_NodePtr>(__root->__left_), __func, __proj))
		669	return true;
		670	}
		671	if (__break(__root))
		672	return true;
		673	std::__invoke(__func, std::__invoke(__proj, static_cast<_Reference>(__root->__get_value())));
		674	if (__root->__right_)
		675	return std::__tree_iterate_from_root<_Reference>(__break, static_cast<_NodePtr>(__root->__right_), __func, __proj);
		676	return false;
		677	}
		678
		679	// Do an in-order traversal of the tree from __first to __last.
		680	template <class _NodeIter, class _Func, class _Proj>
		681	_LIBCPP_HIDE_FROM_ABI void
		682	__tree_iterate_subrange(_NodeIter __first_it, _NodeIter __last_it, _Func& __func, _Proj& __proj) {
		683	using _NodePtr = typename _NodeIter::__node_pointer;
		684	using _Reference = typename _NodeIter::reference;
		685
		686	auto __first = __first_it.__ptr_;
		687	auto __last = __last_it.__ptr_;
		688
		689	while (true) {
		690	if (__first == __last)
		691	return;
		692	const auto __nfirst = static_cast<_NodePtr>(__first);
		693	std::__invoke(__func, std::__invoke(__proj, static_cast<_Reference>(__nfirst->__get_value())));
		694	if (__nfirst->__right_) {
		695	if (std::__tree_iterate_from_root<_Reference>(
		696	[&](_NodePtr __node) -> bool { return __node == __last; },
		697	static_cast<_NodePtr>(__nfirst->__right_),
		698	__func,
		699	__proj))
		700	return;
		701	}
		702	while (!std::__tree_is_left_child(static_cast<_NodePtr>(__first)))
		703	__first = static_cast<_NodePtr>(__first)->__parent_;
		704	__first = static_cast<_NodePtr>(__first)->__parent_;
		705	}
		706	}
		707
633	template <class _Tp, class _NodePtr, class _DiffType>	708	template <class _Tp, class _NodePtr, class _DiffType>
634	class __tree_iterator {	709	class __tree_iterator {
635	typedef __tree_node_types<_NodePtr> _NodeTypes;	710	using _NodeTypes _LIBCPP_NODEBUG = __tree_node_types<_NodePtr>;
636	typedef _NodePtr __node_pointer;	711	// NOLINTNEXTLINE(libcpp-nodebug-on-aliases) lldb relies on this alias for pretty printing
637	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;	712	using __node_pointer = _NodePtr;
638	typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;	713	using __node_base_pointer _LIBCPP_NODEBUG = typename _NodeTypes::__node_base_pointer;
		714	using __end_node_pointer _LIBCPP_NODEBUG = typename _NodeTypes::__end_node_pointer;
639		715
640	__end_node_pointer __ptr_;	716	__end_node_pointer __ptr_;
641		717
...	@@ -646,15 +722,12 @@ public:	...	@@ -646,15 +722,12 @@ public:
646	using reference = value_type&;	722	using reference = value_type&;
647	using pointer = __rebind_pointer_t<_NodePtr, value_type>;	723	using pointer = __rebind_pointer_t<_NodePtr, value_type>;
648		724
649	_LIBCPP_HIDE_FROM_ABI __tree_iterator() _NOEXCEPT	725	_LIBCPP_HIDE_FROM_ABI __tree_iterator() _NOEXCEPT : __ptr_(nullptr) {}
650	#if _LIBCPP_STD_VER >= 14
651	: __ptr_(nullptr)
652	#endif
653	{
654	}
655		726
656	_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }	727	_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__get_value(); }
657	_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }	728	_LIBCPP_HIDE_FROM_ABI pointer operator->() const {
		729	return pointer_traits<pointer>::pointer_to(__get_np()->__get_value());
		730	}
658		731
659	_LIBCPP_HIDE_FROM_ABI __tree_iterator& operator++() {	732	_LIBCPP_HIDE_FROM_ABI __tree_iterator& operator++() {
660	__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));	733	__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));
...	@@ -691,50 +764,54 @@ private:	...	@@ -691,50 +764,54 @@ private:
691	friend class __tree;	764	friend class __tree;
692	template <class, class, class>	765	template <class, class, class>
693	friend class __tree_const_iterator;	766	friend class __tree_const_iterator;
694	template <class>	767
695	friend class __map_iterator;	768	template <class _NodeIter, class _Func, class _Proj>
696	template <class, class, class, class>	769	friend void __tree_iterate_subrange(_NodeIter, _NodeIter, _Func&, _Proj&);
697	friend class map;	770	};
698	template <class, class, class, class>	771
699	friend class multimap;	772	#ifndef _LIBCPP_CXX03_LANG
700	template <class, class, class>	773	// This also handles {multi,}set::iterator, since they're just aliases to __tree::iterator
701	friend class set;	774	template <class _Tp, class _NodePtr, class _DiffType>
702	template <class, class, class>	775	struct __specialized_algorithm<
703	friend class multiset;	776	_Algorithm::__for_each,
		777	__iterator_pair<__tree_iterator<_Tp, _NodePtr, _DiffType>, __tree_iterator<_Tp, _NodePtr, _DiffType>>> {
		778	static const bool __has_algorithm = true;
		779
		780	using __iterator _LIBCPP_NODEBUG = __tree_iterator<_Tp, _NodePtr, _DiffType>;
		781
		782	template <class _Func, class _Proj>
		783	_LIBCPP_HIDE_FROM_ABI static void operator()(__iterator __first, __iterator __last, _Func& __func, _Proj& __proj) {
		784	std::__tree_iterate_subrange(__first, __last, __func, __proj);
		785	}
704	};	786	};
		787	#endif
705		788
706	template <class _Tp, class _NodePtr, class _DiffType>	789	template <class _Tp, class _NodePtr, class _DiffType>
707	class __tree_const_iterator {	790	class __tree_const_iterator {
708	typedef __tree_node_types<_NodePtr> _NodeTypes;	791	using _NodeTypes _LIBCPP_NODEBUG = __tree_node_types<_NodePtr>;
709	// NOLINTNEXTLINE(libcpp-nodebug-on-aliases) lldb relies on this alias for pretty printing	792	// NOLINTNEXTLINE(libcpp-nodebug-on-aliases) lldb relies on this alias for pretty printing
710	using __node_pointer = _NodePtr;	793	using __node_pointer = _NodePtr;
711	typedef typename _NodeTypes::__node_base_pointer __node_base_pointer;	794	using __node_base_pointer _LIBCPP_NODEBUG = typename _NodeTypes::__node_base_pointer;
712	typedef typename _NodeTypes::__end_node_pointer __end_node_pointer;	795	using __end_node_pointer _LIBCPP_NODEBUG = typename _NodeTypes::__end_node_pointer;
713		796
714	__end_node_pointer __ptr_;	797	__end_node_pointer __ptr_;
715		798
716	public:	799	public:
717	using iterator_category = bidirectional_iterator_tag;	800	using iterator_category = bidirectional_iterator_tag;
718	using value_type = __get_node_value_type_t<_Tp>;	801	using value_type = __get_node_value_type_t<_Tp>;
719	using difference_type = _DiffType;	802	using difference_type = _DiffType;
720	using reference = const value_type&;	803	using reference = const value_type&;
721	using pointer = __rebind_pointer_t<_NodePtr, const value_type>;	804	using pointer = __rebind_pointer_t<_NodePtr, const value_type>;
		805	using __non_const_iterator _LIBCPP_NODEBUG = __tree_iterator<_Tp, __node_pointer, difference_type>;
722		806
723	_LIBCPP_HIDE_FROM_ABI __tree_const_iterator() _NOEXCEPT	807	_LIBCPP_HIDE_FROM_ABI __tree_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
724	#if _LIBCPP_STD_VER >= 14
725	: __ptr_(nullptr)
726	#endif
727	{
728	}
729
730	private:
731	typedef __tree_iterator<_Tp, __node_pointer, difference_type> __non_const_iterator;
732		808
733	public:
734	_LIBCPP_HIDE_FROM_ABI __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}	809	_LIBCPP_HIDE_FROM_ABI __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT : __ptr_(__p.__ptr_) {}
735		810
736	_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__value_; }	811	_LIBCPP_HIDE_FROM_ABI reference operator*() const { return __get_np()->__get_value(); }
737	_LIBCPP_HIDE_FROM_ABI pointer operator->() const { return pointer_traits<pointer>::pointer_to(__get_np()->__value_); }	812	_LIBCPP_HIDE_FROM_ABI pointer operator->() const {
		813	return pointer_traits<pointer>::pointer_to(__get_np()->__get_value());
		814	}
738		815
739	_LIBCPP_HIDE_FROM_ABI __tree_const_iterator& operator++() {	816	_LIBCPP_HIDE_FROM_ABI __tree_const_iterator& operator++() {
740	__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));	817	__ptr_ = std::__tree_next_iter<__end_node_pointer>(static_cast<__node_base_pointer>(__ptr_));
...	@@ -772,18 +849,28 @@ private:	...	@@ -772,18 +849,28 @@ private:
772		849
773	template <class, class, class>	850	template <class, class, class>
774	friend class __tree;	851	friend class __tree;
775	template <class, class, class, class>	852
776	friend class map;	853	template <class _NodeIter, class _Func, class _Proj>
777	template <class, class, class, class>	854	friend void __tree_iterate_subrange(_NodeIter, _NodeIter, _Func&, _Proj&);
778	friend class multimap;
779	template <class, class, class>
780	friend class set;
781	template <class, class, class>
782	friend class multiset;
783	template <class>
784	friend class __map_const_iterator;
785	};	855	};
786		856
		857	#ifndef _LIBCPP_CXX03_LANG
		858	// This also handles {multi,}set::const_iterator, since they're just aliases to __tree::iterator
		859	template <class _Tp, class _NodePtr, class _DiffType>
		860	struct __specialized_algorithm<
		861	_Algorithm::__for_each,
		862	__iterator_pair<__tree_const_iterator<_Tp, _NodePtr, _DiffType>, __tree_const_iterator<_Tp, _NodePtr, _DiffType>>> {
		863	static const bool __has_algorithm = true;
		864
		865	using __iterator _LIBCPP_NODEBUG = __tree_const_iterator<_Tp, _NodePtr, _DiffType>;
		866
		867	template <class _Func, class _Proj>
		868	_LIBCPP_HIDE_FROM_ABI static void operator()(__iterator __first, __iterator __last, _Func& __func, _Proj& __proj) {
		869	std::__tree_iterate_subrange(__first, __last, __func, __proj);
		870	}
		871	};
		872	#endif
		873
787	template <class _Tp, class _Compare>	874	template <class _Tp, class _Compare>
788	#ifndef _LIBCPP_CXX03_LANG	875	#ifndef _LIBCPP_CXX03_LANG
789	_LIBCPP_DIAGNOSE_WARNING(!__is_invocable_v<_Compare const&, _Tp const&, _Tp const&>,	876	_LIBCPP_DIAGNOSE_WARNING(!__is_invocable_v<_Compare const&, _Tp const&, _Tp const&>,
...	@@ -794,21 +881,20 @@ int __diagnose_non_const_comparator();	...	@@ -794,21 +881,20 @@ int __diagnose_non_const_comparator();
794	template <class _Tp, class _Compare, class _Allocator>	881	template <class _Tp, class _Compare, class _Allocator>
795	class __tree {	882	class __tree {
796	public:	883	public:
797	using value_type = __get_node_value_type_t<_Tp>;	884	using value_type = __get_node_value_type_t<_Tp>;
798	typedef _Compare value_compare;	885	using value_compare = _Compare;
799	typedef _Allocator allocator_type;	886	using allocator_type = _Allocator;
800		887
801	private:	888	private:
802	typedef allocator_traits<allocator_type> __alloc_traits;	889	using __alloc_traits _LIBCPP_NODEBUG = allocator_traits<allocator_type>;
803	using key_type = __get_tree_key_type_t<_Tp>;	890	using key_type = __get_tree_key_type_t<_Tp>;
804		891
805	public:	892	public:
806	typedef typename __alloc_traits::pointer pointer;	893	using pointer = typename __alloc_traits::pointer;
807	typedef typename __alloc_traits::const_pointer const_pointer;	894	using const_pointer = typename __alloc_traits::const_pointer;
808	typedef typename __alloc_traits::size_type size_type;	895	using size_type = typename __alloc_traits::size_type;
809	typedef typename __alloc_traits::difference_type difference_type;	896	using difference_type = typename __alloc_traits::difference_type;
810		897
811	public:
812	using __void_pointer _LIBCPP_NODEBUG = typename __alloc_traits::void_pointer;	898	using __void_pointer _LIBCPP_NODEBUG = typename __alloc_traits::void_pointer;
813		899
814	using __node _LIBCPP_NODEBUG = __tree_node<_Tp, __void_pointer>;	900	using __node _LIBCPP_NODEBUG = __tree_node<_Tp, __void_pointer>;
...	@@ -821,22 +907,8 @@ public:	...	@@ -821,22 +907,8 @@ public:
821	using __end_node_t _LIBCPP_NODEBUG = __tree_end_node<__node_base_pointer>;	907	using __end_node_t _LIBCPP_NODEBUG = __tree_end_node<__node_base_pointer>;
822	using __end_node_pointer _LIBCPP_NODEBUG = __rebind_pointer_t<__void_pointer, __end_node_t>;	908	using __end_node_pointer _LIBCPP_NODEBUG = __rebind_pointer_t<__void_pointer, __end_node_t>;
823		909
824	using __parent_pointer _LIBCPP_NODEBUG = __end_node_pointer; // TODO: Remove this once the uses in <map> are removed	910	using __node_allocator _LIBCPP_NODEBUG = __rebind_alloc<__alloc_traits, __node>;
825		911	using __node_traits _LIBCPP_NODEBUG = allocator_traits<__node_allocator>;
826	typedef __rebind_alloc<__alloc_traits, __node> __node_allocator;
827	typedef allocator_traits<__node_allocator> __node_traits;
828
829	// TODO(LLVM 22): Remove this check
830	#ifndef _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB
831	static_assert(sizeof(__node_base_pointer) == sizeof(__end_node_pointer) && _LIBCPP_ALIGNOF(__node_base_pointer) ==
832	_LIBCPP_ALIGNOF(__end_node_pointer),
833	"It looks like you are using std::__tree (an implementation detail for (multi)map/set) with a fancy "
834	"pointer type that thas a different representation depending on whether it points to a __tree base "
835	"pointer or a __tree node pointer (both of which are implementation details of the standard library). "
836	"This means that your ABI is being broken between LLVM 19 and LLVM 20. If you don't care about your "
837	"ABI being broken, define the _LIBCPP_ABI_TREE_REMOVE_NODE_POINTER_UB macro to silence this "
838	"diagnostic.");
839	#endif
840		912
841	private:	913	private:
842	// check for sane allocator pointer rebinding semantics. Rebinding the	914	// check for sane allocator pointer rebinding semantics. Rebinding the
...	@@ -844,8 +916,8 @@ private:	...	@@ -844,8 +916,8 @@ private:
844	// the pointer using 'pointer_traits'.	916	// the pointer using 'pointer_traits'.
845	static_assert(is_same<__node_pointer, typename __node_traits::pointer>::value,	917	static_assert(is_same<__node_pointer, typename __node_traits::pointer>::value,
846	"Allocator does not rebind pointers in a sane manner.");	918	"Allocator does not rebind pointers in a sane manner.");
847	typedef __rebind_alloc<__node_traits, __node_base> __node_base_allocator;	919	using __node_base_allocator _LIBCPP_NODEBUG = __rebind_alloc<__node_traits, __node_base>;
848	typedef allocator_traits<__node_base_allocator> __node_base_traits;	920	using __node_base_traits _LIBCPP_NODEBUG = allocator_traits<__node_base_allocator>;
849	static_assert(is_same<__node_base_pointer, typename __node_base_traits::pointer>::value,	921	static_assert(is_same<__node_base_pointer, typename __node_base_traits::pointer>::value,
850	"Allocator does not rebind pointers in a sane manner.");	922	"Allocator does not rebind pointers in a sane manner.");
851		923
...	@@ -865,17 +937,11 @@ public:	...	@@ -865,17 +937,11 @@ public:
865		937
866	private:	938	private:
867	_LIBCPP_HIDE_FROM_ABI const __node_allocator& __node_alloc() const _NOEXCEPT { return __node_alloc_; }	939	_LIBCPP_HIDE_FROM_ABI const __node_allocator& __node_alloc() const _NOEXCEPT { return __node_alloc_; }
868	_LIBCPP_HIDE_FROM_ABI __end_node_pointer& __begin_node() _NOEXCEPT { return __begin_node_; }
869	_LIBCPP_HIDE_FROM_ABI const __end_node_pointer& __begin_node() const _NOEXCEPT { return __begin_node_; }
870		940
871	public:	941	public:
872	_LIBCPP_HIDE_FROM_ABI allocator_type __alloc() const _NOEXCEPT { return allocator_type(__node_alloc()); }	942	_LIBCPP_HIDE_FROM_ABI allocator_type __alloc() const _NOEXCEPT { return allocator_type(__node_alloc()); }
873		943
874	private:	944	_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
875	_LIBCPP_HIDE_FROM_ABI size_type& size() _NOEXCEPT { return __size_; }
876
877	public:
878	_LIBCPP_HIDE_FROM_ABI const size_type& size() const _NOEXCEPT { return __size_; }
879	_LIBCPP_HIDE_FROM_ABI value_compare& value_comp() _NOEXCEPT { return __value_comp_; }	945	_LIBCPP_HIDE_FROM_ABI value_compare& value_comp() _NOEXCEPT { return __value_comp_; }
880	_LIBCPP_HIDE_FROM_ABI const value_compare& value_comp() const _NOEXCEPT { return __value_comp_; }	946	_LIBCPP_HIDE_FROM_ABI const value_compare& value_comp() const _NOEXCEPT { return __value_comp_; }
881		947
...	@@ -888,32 +954,61 @@ public:	...	@@ -888,32 +954,61 @@ public:
888	return std::addressof(__end_node()->__left_);	954	return std::addressof(__end_node()->__left_);
889	}	955	}
890		956
891	typedef __tree_iterator<_Tp, __node_pointer, difference_type> iterator;	957	using iterator = __tree_iterator<_Tp, __node_pointer, difference_type>;
892	typedef __tree_const_iterator<_Tp, __node_pointer, difference_type> const_iterator;	958	using const_iterator = __tree_const_iterator<_Tp, __node_pointer, difference_type>;
893		959
894	_LIBCPP_HIDE_FROM_ABI explicit __tree(const value_compare& __comp) _NOEXCEPT_(	960	_LIBCPP_HIDE_FROM_ABI explicit __tree(const value_compare& __comp) _NOEXCEPT_(
895	is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_copy_constructible<value_compare>::value);	961	is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_copy_constructible<value_compare>::value)
896	_LIBCPP_HIDE_FROM_ABI explicit __tree(const allocator_type& __a);	962	: __size_(0), __value_comp_(__comp) {
897	_LIBCPP_HIDE_FROM_ABI __tree(const value_compare& __comp, const allocator_type& __a);	963	__begin_node_ = __end_node();
		964	}
		965
		966	_LIBCPP_HIDE_FROM_ABI explicit __tree(const allocator_type& __a)
		967	: __begin_node_(), __node_alloc_(__node_allocator(__a)), __size_(0) {
		968	__begin_node_ = __end_node();
		969	}
		970
		971	_LIBCPP_HIDE_FROM_ABI __tree(const value_compare& __comp, const allocator_type& __a)
		972	: __begin_node_(), __node_alloc_(__node_allocator(__a)), __size_(0), __value_comp_(__comp) {
		973	__begin_node_ = __end_node();
		974	}
		975
898	_LIBCPP_HIDE_FROM_ABI __tree(const __tree& __t);	976	_LIBCPP_HIDE_FROM_ABI __tree(const __tree& __t);
		977
		978	_LIBCPP_HIDE_FROM_ABI __tree(const __tree& __other, const allocator_type& __alloc)
		979	: __begin_node_(__end_node()), __node_alloc_(__alloc), __size_(0), __value_comp_(__other.value_comp()) {
		980	if (__other.size() == 0)
		981	return;
		982
		983	*__root_ptr() = static_cast<__node_base_pointer>(__copy_construct_tree(__other.__root()));
		984	__root()->__parent_ = __end_node();
		985	__begin_node_ = static_cast<__end_node_pointer>(std::__tree_min(__end_node()->__left_));
		986	__size_ = __other.size();
		987	}
		988
899	_LIBCPP_HIDE_FROM_ABI __tree& operator=(const __tree& __t);	989	_LIBCPP_HIDE_FROM_ABI __tree& operator=(const __tree& __t);
900	template <class _ForwardIterator>	990	template <class _ForwardIterator>
901	_LIBCPP_HIDE_FROM_ABI void __assign_unique(_ForwardIterator __first, _ForwardIterator __last);	991	_LIBCPP_HIDE_FROM_ABI void __assign_unique(_ForwardIterator __first, _ForwardIterator __last);
902	template <class _InputIterator>
903	_LIBCPP_HIDE_FROM_ABI void __assign_multi(_InputIterator __first, _InputIterator __last);
904	_LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t) _NOEXCEPT_(	992	_LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t) _NOEXCEPT_(
905	is_nothrow_move_constructible<__node_allocator>::value&& is_nothrow_move_constructible<value_compare>::value);	993	is_nothrow_move_constructible<__node_allocator>::value&& is_nothrow_move_constructible<value_compare>::value);
906	_LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t, const allocator_type& __a);	994	_LIBCPP_HIDE_FROM_ABI __tree(__tree&& __t, const allocator_type& __a);
		995
907	_LIBCPP_HIDE_FROM_ABI __tree& operator=(__tree&& __t)	996	_LIBCPP_HIDE_FROM_ABI __tree& operator=(__tree&& __t)
908	_NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&	997	_NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
909	((__node_traits::propagate_on_container_move_assignment::value &&	998	((__node_traits::propagate_on_container_move_assignment::value &&
910	is_nothrow_move_assignable<__node_allocator>::value) \|\|	999	is_nothrow_move_assignable<__node_allocator>::value) \|\|
911	allocator_traits<__node_allocator>::is_always_equal::value));	1000	allocator_traits<__node_allocator>::is_always_equal::value)) {
		1001	__move_assign(__t, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
		1002	return *this;
		1003	}
912		1004
913	_LIBCPP_HIDE_FROM_ABI ~__tree();	1005	_LIBCPP_HIDE_FROM_ABI ~__tree() {
		1006	static_assert(is_copy_constructible<value_compare>::value, "Comparator must be copy-constructible.");
		1007	destroy(__root());
		1008	}
914		1009
915	_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return iterator(__begin_node()); }	1010	_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return iterator(__begin_node_); }
916	_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return const_iterator(__begin_node()); }	1011	_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return const_iterator(__begin_node_); }
917	_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return iterator(__end_node()); }	1012	_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return iterator(__end_node()); }
918	_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return const_iterator(__end_node()); }	1013	_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return const_iterator(__end_node()); }
919		1014
...	@@ -931,116 +1026,151 @@ public:	...	@@ -931,116 +1026,151 @@ public:
931	_NOEXCEPT_(__is_nothrow_swappable_v<value_compare>);	1026	_NOEXCEPT_(__is_nothrow_swappable_v<value_compare>);
932	#endif	1027	#endif
933		1028
934	template <class _Key, class... _Args>
935	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_key_args(_Key const&, _Args&&... __args);
936	template <class _Key, class... _Args>
937	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_hint_unique_key_args(const_iterator, _Key const&, _Args&&...);
938
939	template <class... _Args>
940	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_impl(_Args&&... __args);
941
942	template <class... _Args>
943	_LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique_impl(const_iterator __p, _Args&&... __args);
944
945	template <class... _Args>	1029	template <class... _Args>
946	_LIBCPP_HIDE_FROM_ABI iterator __emplace_multi(_Args&&... __args);	1030	_LIBCPP_HIDE_FROM_ABI iterator __emplace_multi(_Args&&... __args);
947		1031
948	template <class... _Args>	1032	template <class... _Args>
949	_LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);	1033	_LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_multi(const_iterator __p, _Args&&... __args);
950		1034
951	template <class _Pp>
952	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Pp&& __x) {
953	return __emplace_unique_extract_key(std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>());
954	}
955
956	template <class _First,
957	class _Second,
958	__enable_if_t<__can_extract_map_key<_First, key_type, value_type>::value, int> = 0>
959	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_First&& __f, _Second&& __s) {
960	return __emplace_unique_key_args(__f, std::forward<_First>(__f), std::forward<_Second>(__s));
961	}
962
963	template <class... _Args>	1035	template <class... _Args>
964	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Args&&... __args) {	1036	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique(_Args&&... __args) {
965	return __emplace_unique_impl(std::forward<_Args>(__args)...);	1037	return std::__try_key_extraction<key_type>(
966	}	1038	[this](const key_type& __key, _Args&&... __args2) {
967		1039	auto [__parent, __child] = __find_equal(__key);
968	template <class _Pp>	1040	__node_pointer __r = static_cast<__node_pointer>(__child);
969	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_fail_tag) {	1041	bool __inserted = false;
970	return __emplace_unique_impl(std::forward<_Pp>(__x));	1042	if (__child == nullptr) {
971	}	1043	__node_holder __h = __construct_node(std::forward<_Args>(__args2)...);
972		1044	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
973	template <class _Pp>	1045	__r = __h.release();
974	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_self_tag) {	1046	__inserted = true;
975	return __emplace_unique_key_args(__x, std::forward<_Pp>(__x));	1047	}
976	}	1048	return pair<iterator, bool>(iterator(__r), __inserted);
977		1049	},
978	template <class _Pp>	1050	[this](_Args&&... __args2) {
979	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_unique_extract_key(_Pp&& __x, __extract_key_first_tag) {	1051	__node_holder __h = __construct_node(std::forward<_Args>(__args2)...);
980	return __emplace_unique_key_args(__x.first, std::forward<_Pp>(__x));	1052	auto [__parent, __child] = __find_equal(__h->__get_value());
981	}	1053	__node_pointer __r = static_cast<__node_pointer>(__child);
982		1054	bool __inserted = false;
983	template <class _Pp>	1055	if (__child == nullptr) {
984	_LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique(const_iterator __p, _Pp&& __x) {	1056	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
985	return __emplace_hint_unique_extract_key(__p, std::forward<_Pp>(__x), __can_extract_key<_Pp, key_type>());	1057	__r = __h.release();
986	}	1058	__inserted = true;
987		1059	}
988	template <class _First,	1060	return pair<iterator, bool>(iterator(__r), __inserted);
989	class _Second,	1061	},
990	__enable_if_t<__can_extract_map_key<_First, key_type, value_type>::value, int> = 0>	1062	std::forward<_Args>(__args)...);
991	_LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique(const_iterator __p, _First&& __f, _Second&& __s) {
992	return __emplace_hint_unique_key_args(__p, __f, std::forward<_First>(__f), std::forward<_Second>(__s)).first;
993	}	1063	}
994		1064
995	template <class... _Args>	1065	template <class... _Args>
996	_LIBCPP_HIDE_FROM_ABI iterator __emplace_hint_unique(const_iterator __p, _Args&&... __args) {	1066	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __emplace_hint_unique(const_iterator __p, _Args&&... __args) {
997	return __emplace_hint_unique_impl(__p, std::forward<_Args>(__args)...);	1067	return std::__try_key_extraction<key_type>(
		1068	[this, __p](const key_type& __key, _Args&&... __args2) {
		1069	__node_base_pointer __dummy;
		1070	auto [__parent, __child] = __find_equal(__p, __dummy, __key);
		1071	__node_pointer __r = static_cast<__node_pointer>(__child);
		1072	bool __inserted = false;
		1073	if (__child == nullptr) {
		1074	__node_holder __h = __construct_node(std::forward<_Args>(__args2)...);
		1075	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
		1076	__r = __h.release();
		1077	__inserted = true;
		1078	}
		1079	return pair<iterator, bool>(iterator(__r), __inserted);
		1080	},
		1081	[this, __p](_Args&&... __args2) {
		1082	__node_holder __h = __construct_node(std::forward<_Args>(__args2)...);
		1083	__node_base_pointer __dummy;
		1084	auto [__parent, __child] = __find_equal(__p, __dummy, __h->__get_value());
		1085	__node_pointer __r = static_cast<__node_pointer>(__child);
		1086	if (__child == nullptr) {
		1087	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
		1088	__r = __h.release();
		1089	}
		1090	return pair<iterator, bool>(iterator(__r), __child == nullptr);
		1091	},
		1092	std::forward<_Args>(__args)...);
998	}	1093	}
999		1094
1000	template <class _Pp>	1095	template <class _InIter, class _Sent>
1001	_LIBCPP_HIDE_FROM_ABI iterator	1096	_LIBCPP_HIDE_FROM_ABI void __insert_range_multi(_InIter __first, _Sent __last) {
1002	__emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_fail_tag) {	1097	if (__first == __last)
1003	return __emplace_hint_unique_impl(__p, std::forward<_Pp>(__x));	1098	return;
1004	}
1005		1099
1006	template <class _Pp>	1100	if (__root() == nullptr) { // Make sure we always have a root node
1007	_LIBCPP_HIDE_FROM_ABI iterator	1101	__insert_node_at(
1008	__emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_self_tag) {	1102	__end_node(), __end_node()->__left_, static_cast<__node_base_pointer>(__construct_node(*__first).release()));
1009	return __emplace_hint_unique_key_args(__p, __x, std::forward<_Pp>(__x)).first;	1103	++__first;
1010	}	1104	}
1011		1105
1012	template <class _Pp>	1106	auto __max_node = static_cast<__node_pointer>(std::__tree_max(static_cast<__node_base_pointer>(__root())));
1013	_LIBCPP_HIDE_FROM_ABI iterator
1014	__emplace_hint_unique_extract_key(const_iterator __p, _Pp&& __x, __extract_key_first_tag) {
1015	return __emplace_hint_unique_key_args(__p, __x.first, std::forward<_Pp>(__x)).first;
1016	}
1017		1107
1018	template <class _ValueT = _Tp, __enable_if_t<__is_tree_value_type<_ValueT>::value, int> = 0>	1108	for (; __first != __last; ++__first) {
1019	_LIBCPP_HIDE_FROM_ABI void	1109	__node_holder __nd = __construct_node(*__first);
1020	__insert_unique_from_orphaned_node(const_iterator __p, __get_node_value_type_t<_Tp>&& __value) {	1110	// Always check the max node first. This optimizes for sorted ranges inserted at the end.
1021	__emplace_hint_unique(__p, const_cast<key_type&&>(__value.first), std::move(__value.second));	1111	if (!value_comp()(__nd->__get_value(), __max_node->__get_value())) { // __node >= __max_val
		1112	__insert_node_at(static_cast<__end_node_pointer>(__max_node),
		1113	__max_node->__right_,
		1114	static_cast<__node_base_pointer>(__nd.get()));
		1115	__max_node = __nd.release();
		1116	} else {
		1117	__end_node_pointer __parent;
		1118	__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__get_value());
		1119	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd.release()));
		1120	}
		1121	}
1022	}	1122	}
1023		1123
1024	template <class _ValueT = _Tp, __enable_if_t<!__is_tree_value_type<_ValueT>::value, int> = 0>	1124	template <class _InIter, class _Sent>
1025	_LIBCPP_HIDE_FROM_ABI void __insert_unique_from_orphaned_node(const_iterator __p, _Tp&& __value) {	1125	_LIBCPP_HIDE_FROM_ABI void __insert_range_unique(_InIter __first, _Sent __last) {
1026	__emplace_hint_unique(__p, std::move(__value));	1126	if (__first == __last)
1027	}	1127	return;
1028		1128
1029	template <class _ValueT = _Tp, __enable_if_t<__is_tree_value_type<_ValueT>::value, int> = 0>	1129	if (__root() == nullptr) {
1030	_LIBCPP_HIDE_FROM_ABI void __insert_multi_from_orphaned_node(const_iterator __p, value_type&& __value) {	1130	__insert_node_at(
1031	__emplace_hint_multi(__p, const_cast<key_type&&>(__value.first), std::move(__value.second));	1131	__end_node(), __end_node()->__left_, static_cast<__node_base_pointer>(__construct_node(*__first).release()));
1032	}	1132	++__first;
		1133	}
1033		1134
1034	template <class _ValueT = _Tp, __enable_if_t<!__is_tree_value_type<_ValueT>::value, int> = 0>	1135	auto __max_node = static_cast<__node_pointer>(std::__tree_max(static_cast<__node_base_pointer>(__root())));
1035	_LIBCPP_HIDE_FROM_ABI void __insert_multi_from_orphaned_node(const_iterator __p, _Tp&& __value) {	1136
1036	__emplace_hint_multi(__p, std::move(__value));	1137	using __reference = decltype(*__first);
		1138
		1139	for (; __first != __last; ++__first) {
		1140	std::__try_key_extraction<key_type>(
		1141	[this, &__max_node](const key_type& __key, __reference&& __val) {
		1142	if (value_comp()(__max_node->__get_value(), __key)) { // __key > __max_node
		1143	__node_holder __nd = __construct_node(std::forward<__reference>(__val));
		1144	__insert_node_at(static_cast<__end_node_pointer>(__max_node),
		1145	__max_node->__right_,
		1146	static_cast<__node_base_pointer>(__nd.get()));
		1147	__max_node = __nd.release();
		1148	} else {
		1149	auto [__parent, __child] = __find_equal(__key);
		1150	if (__child == nullptr) {
		1151	__node_holder __nd = __construct_node(std::forward<__reference>(__val));
		1152	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd.release()));
		1153	}
		1154	}
		1155	},
		1156	[this, &__max_node](__reference&& __val) {
		1157	__node_holder __nd = __construct_node(std::forward<__reference>(__val));
		1158	if (value_comp()(__max_node->__get_value(), __nd->__get_value())) { // __node > __max_node
		1159	__insert_node_at(static_cast<__end_node_pointer>(__max_node),
		1160	__max_node->__right_,
		1161	static_cast<__node_base_pointer>(__nd.get()));
		1162	__max_node = __nd.release();
		1163	} else {
		1164	auto [__parent, __child] = __find_equal(__nd->__get_value());
		1165	if (__child == nullptr) {
		1166	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd.release()));
		1167	}
		1168	}
		1169	},
		1170	*__first);
		1171	}
1037	}	1172	}
1038		1173
1039	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> __node_assign_unique(const value_type& __v, __node_pointer __dest);
1040
1041	_LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(__node_pointer __nd);
1042	_LIBCPP_HIDE_FROM_ABI iterator __node_insert_multi(const_iterator __p, __node_pointer __nd);
1043
1044	_LIBCPP_HIDE_FROM_ABI iterator __remove_node_pointer(__node_pointer) _NOEXCEPT;	1174	_LIBCPP_HIDE_FROM_ABI iterator __remove_node_pointer(__node_pointer) _NOEXCEPT;
1045		1175
1046	#if _LIBCPP_STD_VER >= 17	1176	#if _LIBCPP_STD_VER >= 17
...	@@ -1048,15 +1178,15 @@ public:	...	@@ -1048,15 +1178,15 @@ public:
1048	_LIBCPP_HIDE_FROM_ABI _InsertReturnType __node_handle_insert_unique(_NodeHandle&&);	1178	_LIBCPP_HIDE_FROM_ABI _InsertReturnType __node_handle_insert_unique(_NodeHandle&&);
1049	template <class _NodeHandle>	1179	template <class _NodeHandle>
1050	_LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&);	1180	_LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_unique(const_iterator, _NodeHandle&&);
1051	template <class _Tree>	1181	template <class _Comp2>
1052	_LIBCPP_HIDE_FROM_ABI void __node_handle_merge_unique(_Tree& __source);	1182	_LIBCPP_HIDE_FROM_ABI void __node_handle_merge_unique(__tree<_Tp, _Comp2, _Allocator>& __source);
1053		1183
1054	template <class _NodeHandle>	1184	template <class _NodeHandle>
1055	_LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(_NodeHandle&&);	1185	_LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(_NodeHandle&&);
1056	template <class _NodeHandle>	1186	template <class _NodeHandle>
1057	_LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(const_iterator, _NodeHandle&&);	1187	_LIBCPP_HIDE_FROM_ABI iterator __node_handle_insert_multi(const_iterator, _NodeHandle&&);
1058	template <class _Tree>	1188	template <class _Comp2>
1059	_LIBCPP_HIDE_FROM_ABI void __node_handle_merge_multi(_Tree& __source);	1189	_LIBCPP_HIDE_FROM_ABI void __node_handle_merge_multi(__tree<_Tp, _Comp2, _Allocator>& __source);
1060		1190
1061	template <class _NodeHandle>	1191	template <class _NodeHandle>
1062	_LIBCPP_HIDE_FROM_ABI _NodeHandle __node_handle_extract(key_type const&);	1192	_LIBCPP_HIDE_FROM_ABI _NodeHandle __node_handle_extract(key_type const&);
...	@@ -1075,41 +1205,157 @@ public:	...	@@ -1075,41 +1205,157 @@ public:
1075	__insert_node_at(__end_node_pointer __parent, __node_base_pointer& __child, __node_base_pointer __new_node) _NOEXCEPT;	1205	__insert_node_at(__end_node_pointer __parent, __node_base_pointer& __child, __node_base_pointer __new_node) _NOEXCEPT;
1076		1206
1077	template <class _Key>	1207	template <class _Key>
1078	_LIBCPP_HIDE_FROM_ABI iterator find(const _Key& __v);	1208	_LIBCPP_HIDE_FROM_ABI iterator find(const _Key& __key) {
		1209	auto [__, __match] = __find_equal(__key);
		1210	if (__match == nullptr)
		1211	return end();
		1212	return iterator(static_cast<__node_pointer>(__match));
		1213	}
		1214
1079	template <class _Key>	1215	template <class _Key>
1080	_LIBCPP_HIDE_FROM_ABI const_iterator find(const _Key& __v) const;	1216	_LIBCPP_HIDE_FROM_ABI const_iterator find(const _Key& __key) const {
		1217	auto [__, __match] = __find_equal(__key);
		1218	if (__match == nullptr)
		1219	return end();
		1220	return const_iterator(static_cast<__node_pointer>(__match));
		1221	}
1081		1222
1082	template <class _Key>	1223	template <class _Key>
1083	_LIBCPP_HIDE_FROM_ABI size_type __count_unique(const _Key& __k) const;	1224	_LIBCPP_HIDE_FROM_ABI size_type __count_unique(const _Key& __k) const;
1084	template <class _Key>	1225	template <class _Key>
1085	_LIBCPP_HIDE_FROM_ABI size_type __count_multi(const _Key& __k) const;	1226	_LIBCPP_HIDE_FROM_ABI size_type __count_multi(const _Key& __k) const;
1086		1227
		1228	template <bool _LowerBound, class _Key>
		1229	_LIBCPP_HIDE_FROM_ABI __end_node_pointer __lower_upper_bound_unique_impl(const _Key& __v) const {
		1230	auto __rt = __root();
		1231	auto __result = __end_node();
		1232	auto __comp = __lazy_synth_three_way_comparator<_Compare, _Key, value_type>(value_comp());
		1233	while (__rt != nullptr) {
		1234	auto __comp_res = __comp(__v, __rt->__get_value());
		1235
		1236	if (__comp_res.__less()) {
		1237	__result = static_cast<__end_node_pointer>(__rt);
		1238	__rt = static_cast<__node_pointer>(__rt->__left_);
		1239	} else if (__comp_res.__greater()) {
		1240	__rt = static_cast<__node_pointer>(__rt->__right_);
		1241	} else if _LIBCPP_CONSTEXPR (_LowerBound) {
		1242	return static_cast<__end_node_pointer>(__rt);
		1243	} else {
		1244	return __rt->__right_ ? static_cast<__end_node_pointer>(std::__tree_min(__rt->__right_)) : __result;
		1245	}
		1246	}
		1247	return __result;
		1248	}
		1249
		1250	// Compatibility escape hatch for comparators that are not strict weak orderings. This
		1251	// can be removed for the LLVM 23 release.
		1252	#if defined(_LIBCPP_ENABLE_LEGACY_TREE_LOWER_UPPER_BOUND)
1087	template <class _Key>	1253	template <class _Key>
1088	_LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _Key& __v) {	1254	_LIBCPP_HIDE_FROM_ABI __end_node_pointer __lower_bound_unique_compat_impl(const _Key& __v) const {
1089	return __lower_bound(__v, __root(), __end_node());	1255	auto __rt = __root();
		1256	auto __result = __end_node();
		1257	while (__rt != nullptr) {
		1258	if (!value_comp()(__rt->__get_value(), __v)) {
		1259	__result = std::__static_fancy_pointer_cast<__end_node_pointer>(__rt);
		1260	__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__left_);
		1261	} else {
		1262	__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__right_);
		1263	}
		1264	}
		1265	return __result;
1090	}	1266	}
		1267
1091	template <class _Key>	1268	template <class _Key>
1092	_LIBCPP_HIDE_FROM_ABI iterator __lower_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result);	1269	_LIBCPP_HIDE_FROM_ABI __end_node_pointer __upper_bound_unique_compat_impl(const _Key& __v) const {
		1270	auto __rt = __root();
		1271	auto __result = __end_node();
		1272	while (__rt != nullptr) {
		1273	if (value_comp()(__v, __rt->__get_value())) {
		1274	__result = std::__static_fancy_pointer_cast<__end_node_pointer>(__rt);
		1275	__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__left_);
		1276	} else {
		1277	__rt = std::__static_fancy_pointer_cast<__node_pointer>(__rt->__right_);
		1278	}
		1279	}
		1280	return __result;
		1281	}
		1282	#endif // _LIBCPP_ENABLE_LEGACY_TREE_LOWER_UPPER_BOUND
		1283
1093	template <class _Key>	1284	template <class _Key>
1094	_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _Key& __v) const {	1285	_LIBCPP_HIDE_FROM_ABI iterator __lower_bound_unique(const _Key& __v) {
1095	return __lower_bound(__v, __root(), __end_node());	1286	#if defined(_LIBCPP_ENABLE_LEGACY_TREE_LOWER_UPPER_BOUND)
		1287	return iterator(__lower_bound_unique_compat_impl(__v));
		1288	#else
		1289	return iterator(__lower_upper_bound_unique_impl<true>(__v));
		1290	#endif
1096	}	1291	}
		1292
		1293	template <class _Key>
		1294	_LIBCPP_HIDE_FROM_ABI const_iterator __lower_bound_unique(const _Key& __v) const {
		1295	#if defined(_LIBCPP_ENABLE_LEGACY_TREE_LOWER_UPPER_BOUND)
		1296	return const_iterator(__lower_bound_unique_compat_impl(__v));
		1297	#else
		1298	return const_iterator(__lower_upper_bound_unique_impl<true>(__v));
		1299	#endif
		1300	}
		1301
		1302	template <class _Key>
		1303	_LIBCPP_HIDE_FROM_ABI iterator __upper_bound_unique(const _Key& __v) {
		1304	#if defined(_LIBCPP_ENABLE_LEGACY_TREE_LOWER_UPPER_BOUND)
		1305	return iterator(__upper_bound_unique_compat_impl(__v));
		1306	#else
		1307	return iterator(__lower_upper_bound_unique_impl<false>(__v));
		1308	#endif
		1309	}
		1310
		1311	template <class _Key>
		1312	_LIBCPP_HIDE_FROM_ABI const_iterator __upper_bound_unique(const _Key& __v) const {
		1313	#if defined(_LIBCPP_ENABLE_LEGACY_TREE_LOWER_UPPER_BOUND)
		1314	return iterator(__upper_bound_unique_compat_impl(__v));
		1315	#else
		1316	return iterator(__lower_upper_bound_unique_impl<false>(__v));
		1317	#endif
		1318	}
		1319
		1320	private:
		1321	template <class _Key>
		1322	_LIBCPP_HIDE_FROM_ABI iterator
		1323	__lower_bound_multi(const _Key& __v, __node_pointer __root, __end_node_pointer __result);
		1324
1097	template <class _Key>	1325	template <class _Key>
1098	_LIBCPP_HIDE_FROM_ABI const_iterator	1326	_LIBCPP_HIDE_FROM_ABI const_iterator
1099	__lower_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) const;	1327	__lower_bound_multi(const _Key& __v, __node_pointer __root, __end_node_pointer __result) const;
		1328
		1329	public:
1100	template <class _Key>	1330	template <class _Key>
1101	_LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _Key& __v) {	1331	_LIBCPP_HIDE_FROM_ABI iterator __lower_bound_multi(const _Key& __v) {
1102	return __upper_bound(__v, __root(), __end_node());	1332	return __lower_bound_multi(__v, __root(), __end_node());
1103	}	1333	}
1104	template <class _Key>	1334	template <class _Key>
1105	_LIBCPP_HIDE_FROM_ABI iterator __upper_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result);	1335	_LIBCPP_HIDE_FROM_ABI const_iterator __lower_bound_multi(const _Key& __v) const {
		1336	return __lower_bound_multi(__v, __root(), __end_node());
		1337	}
		1338
		1339	template <class _Key>
		1340	_LIBCPP_HIDE_FROM_ABI iterator __upper_bound_multi(const _Key& __v) {
		1341	return __upper_bound_multi(__v, __root(), __end_node());
		1342	}
		1343
1106	template <class _Key>	1344	template <class _Key>
1107	_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _Key& __v) const {	1345	_LIBCPP_HIDE_FROM_ABI const_iterator __upper_bound_multi(const _Key& __v) const {
1108	return __upper_bound(__v, __root(), __end_node());	1346	return __upper_bound_multi(__v, __root(), __end_node());
1109	}	1347	}
		1348
		1349	private:
		1350	template <class _Key>
		1351	_LIBCPP_HIDE_FROM_ABI iterator
		1352	__upper_bound_multi(const _Key& __v, __node_pointer __root, __end_node_pointer __result);
		1353
1110	template <class _Key>	1354	template <class _Key>
1111	_LIBCPP_HIDE_FROM_ABI const_iterator	1355	_LIBCPP_HIDE_FROM_ABI const_iterator
1112	__upper_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) const;	1356	__upper_bound_multi(const _Key& __v, __node_pointer __root, __end_node_pointer __result) const;
		1357
		1358	public:
1113	template <class _Key>	1359	template <class _Key>
1114	_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> __equal_range_unique(const _Key& __k);	1360	_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> __equal_range_unique(const _Key& __k);
1115	template <class _Key>	1361	template <class _Key>
...	@@ -1120,22 +1366,24 @@ public:	...	@@ -1120,22 +1366,24 @@ public:
1120	template <class _Key>	1366	template <class _Key>
1121	_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> __equal_range_multi(const _Key& __k) const;	1367	_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> __equal_range_multi(const _Key& __k) const;
1122		1368
1123	typedef __tree_node_destructor<__node_allocator> _Dp;	1369	using _Dp _LIBCPP_NODEBUG = __tree_node_destructor<__node_allocator>;
1124	typedef unique_ptr<__node, _Dp> __node_holder;	1370	using __node_holder _LIBCPP_NODEBUG = unique_ptr<__node, _Dp>;
1125		1371
1126	_LIBCPP_HIDE_FROM_ABI __node_holder remove(const_iterator __p) _NOEXCEPT;	1372	_LIBCPP_HIDE_FROM_ABI __node_holder remove(const_iterator __p) _NOEXCEPT;
1127		1373
1128	// FIXME: Make this function const qualified. Unfortunately doing so	1374	// FIXME: Make this function const qualified. Unfortunately doing so
1129	// breaks existing code which uses non-const callable comparators.	1375	// breaks existing code which uses non-const callable comparators.
1130	template <class _Key>	1376	template <class _Key>
1131	_LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_equal(__end_node_pointer& __parent, const _Key& __v);	1377	_LIBCPP_HIDE_FROM_ABI pair<__end_node_pointer, __node_base_pointer&> __find_equal(const _Key& __v);
		1378
1132	template <class _Key>	1379	template <class _Key>
1133	_LIBCPP_HIDE_FROM_ABI __node_base_pointer& __find_equal(__end_node_pointer& __parent, const _Key& __v) const {	1380	_LIBCPP_HIDE_FROM_ABI pair<__end_node_pointer, __node_base_pointer&> __find_equal(const _Key& __v) const {
1134	return const_cast<__tree*>(this)->__find_equal(__parent, __v);	1381	return const_cast<__tree*>(this)->__find_equal(__v);
1135	}	1382	}
		1383
1136	template <class _Key>	1384	template <class _Key>
1137	_LIBCPP_HIDE_FROM_ABI __node_base_pointer&	1385	_LIBCPP_HIDE_FROM_ABI pair<__end_node_pointer, __node_base_pointer&>
1138	__find_equal(const_iterator __hint, __end_node_pointer& __parent, __node_base_pointer& __dummy, const _Key& __v);	1386	__find_equal(const_iterator __hint, __node_base_pointer& __dummy, const _Key& __v);
1139		1387
1140	_LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __tree& __t) {	1388	_LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const __tree& __t) {
1141	__copy_assign_alloc(__t, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());	1389	__copy_assign_alloc(__t, integral_constant<bool, __node_traits::propagate_on_container_copy_assignment::value>());
...	@@ -1160,7 +1408,7 @@ private:	...	@@ -1160,7 +1408,7 @@ private:
1160	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&&... __args);	1408	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node(_Args&&... __args);
1161		1409
1162	// TODO: Make this _LIBCPP_HIDE_FROM_ABI	1410	// TODO: Make this _LIBCPP_HIDE_FROM_ABI
1163	_LIBCPP_HIDDEN void destroy(__node_pointer __nd) _NOEXCEPT;	1411	_LIBCPP_HIDDEN void destroy(__node_pointer __nd) _NOEXCEPT { (__tree_deleter(__node_alloc_))(__nd); }
1164		1412
1165	_LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, false_type);	1413	_LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, false_type);
1166	_LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, true_type) _NOEXCEPT_(	1414	_LIBCPP_HIDE_FROM_ABI void __move_assign(__tree& __t, true_type) _NOEXCEPT_(
...	@@ -1178,7 +1426,7 @@ private:	...	@@ -1178,7 +1426,7 @@ private:
1178	}	1426	}
1179	_LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__tree&, false_type) _NOEXCEPT {}	1427	_LIBCPP_HIDE_FROM_ABI void __move_assign_alloc(__tree&, false_type) _NOEXCEPT {}
1180		1428
1181	template <class _From, class _ValueT = _Tp, __enable_if_t<__is_tree_value_type<_ValueT>::value, int> = 0>	1429	template <class _From, class _ValueT = _Tp, __enable_if_t<__is_tree_value_type_v<_ValueT>, int> = 0>
1182	_LIBCPP_HIDE_FROM_ABI static void __assign_value(__get_node_value_type_t<value_type>& __lhs, _From&& __rhs) {	1430	_LIBCPP_HIDE_FROM_ABI static void __assign_value(__get_node_value_type_t<value_type>& __lhs, _From&& __rhs) {
1183	using __key_type = __remove_const_t<typename value_type::first_type>;	1431	using __key_type = __remove_const_t<typename value_type::first_type>;
1184		1432
...	@@ -1188,166 +1436,203 @@ private:	...	@@ -1188,166 +1436,203 @@ private:
1188	__lhs.second = std::forward<_From>(__rhs).second;	1436	__lhs.second = std::forward<_From>(__rhs).second;
1189	}	1437	}
1190		1438
1191	template <class _To, class _From, class _ValueT = _Tp, __enable_if_t<!__is_tree_value_type<_ValueT>::value, int> = 0>	1439	template <class _To, class _From, class _ValueT = _Tp, __enable_if_t<!__is_tree_value_type_v<_ValueT>, int> = 0>
1192	_LIBCPP_HIDE_FROM_ABI static void __assign_value(_To& __lhs, _From&& __rhs) {	1440	_LIBCPP_HIDE_FROM_ABI static void __assign_value(_To& __lhs, _From&& __rhs) {
1193	__lhs = std::forward<_From>(__rhs);	1441	__lhs = std::forward<_From>(__rhs);
1194	}	1442	}
1195		1443
1196	struct _DetachedTreeCache {	1444	class __tree_deleter {
1197	_LIBCPP_HIDE_FROM_ABI explicit _DetachedTreeCache(__tree* __t) _NOEXCEPT	1445	__node_allocator& __alloc_;
1198	: __t_(__t),	1446
1199	__cache_root_(__detach_from_tree(__t)) {	1447	public:
1200	__advance();	1448	using pointer = __node_pointer;
		1449
		1450	_LIBCPP_HIDE_FROM_ABI __tree_deleter(__node_allocator& __alloc) : __alloc_(__alloc) {}
		1451
		1452	#ifdef _LIBCPP_COMPILER_CLANG_BASED // FIXME: GCC complains about not being able to always_inline a recursive function
		1453	_LIBCPP_HIDE_FROM_ABI
		1454	#endif
		1455	void
		1456	operator()(__node_pointer __ptr) {
		1457	if (!__ptr)
		1458	return;
		1459
		1460	(*this)(static_cast<__node_pointer>(__ptr->__left_));
		1461
		1462	auto __right = __ptr->__right_;
		1463
		1464	__node_traits::destroy(__alloc_, std::addressof(__ptr->__get_value()));
		1465	__node_traits::deallocate(__alloc_, __ptr, 1);
		1466
		1467	(*this)(static_cast<__node_pointer>(__right));
1201	}	1468	}
		1469	};
		1470
		1471	// This copy construction will always produce a correct red-black-tree assuming the incoming tree is correct, since we
		1472	// copy the exact structure 1:1. Since this is for copy construction _only_ we know that we get a correct tree. If we
		1473	// didn't get a correct tree, the invariants of __tree are broken and we have a much bigger problem than an improperly
		1474	// balanced tree.
		1475	template <class _NodeConstructor>
		1476	#ifdef _LIBCPP_COMPILER_CLANG_BASED // FIXME: GCC complains about not being able to always_inline a recursive function
		1477	_LIBCPP_HIDE_FROM_ABI
		1478	#endif
		1479	__node_pointer __construct_from_tree(__node_pointer __src, _NodeConstructor __construct) {
		1480	if (!__src)
		1481	return nullptr;
1202		1482
1203	_LIBCPP_HIDE_FROM_ABI __node_pointer __get() const _NOEXCEPT { return __cache_elem_; }	1483	__node_holder __new_node = __construct(__src->__get_value());
1204		1484
1205	_LIBCPP_HIDE_FROM_ABI void __advance() _NOEXCEPT {	1485	unique_ptr<__node, __tree_deleter> __left(
1206	__cache_elem_ = __cache_root_;	1486	__construct_from_tree(static_cast<__node_pointer>(__src->__left_), __construct), __node_alloc_);
1207	if (__cache_root_) {	1487	__node_pointer __right = __construct_from_tree(static_cast<__node_pointer>(__src->__right_), __construct);
1208	__cache_root_ = __detach_next(__cache_root_);	1488
1209	}	1489	__node_pointer __new_node_ptr = __new_node.release();
		1490
		1491	__new_node_ptr->__is_black_ = __src->__is_black_;
		1492	__new_node_ptr->__left_ = static_cast<__node_base_pointer>(__left.release());
		1493	__new_node_ptr->__right_ = static_cast<__node_base_pointer>(__right);
		1494	if (__new_node_ptr->__left_)
		1495	__new_node_ptr->__left_->__parent_ = static_cast<__end_node_pointer>(__new_node_ptr);
		1496	if (__new_node_ptr->__right_)
		1497	__new_node_ptr->__right_->__parent_ = static_cast<__end_node_pointer>(__new_node_ptr);
		1498	return __new_node_ptr;
		1499	}
		1500
		1501	_LIBCPP_HIDE_FROM_ABI __node_pointer __copy_construct_tree(__node_pointer __src) {
		1502	return __construct_from_tree(__src, [this](const value_type& __val) { return __construct_node(__val); });
		1503	}
		1504
		1505	template <class _ValueT = _Tp, __enable_if_t<__is_tree_value_type_v<_ValueT>, int> = 0>
		1506	_LIBCPP_HIDE_FROM_ABI __node_pointer __move_construct_tree(__node_pointer __src) {
		1507	return __construct_from_tree(__src, [this](value_type& __val) {
		1508	return __construct_node(const_cast<key_type&&>(__val.first), std::move(__val.second));
		1509	});
		1510	}
		1511
		1512	template <class _ValueT = _Tp, __enable_if_t<!__is_tree_value_type_v<_ValueT>, int> = 0>
		1513	_LIBCPP_HIDE_FROM_ABI __node_pointer __move_construct_tree(__node_pointer __src) {
		1514	return __construct_from_tree(__src, [this](value_type& __val) { return __construct_node(std::move(__val)); });
		1515	}
		1516
		1517	template <class _Assignment, class _ConstructionAlg>
		1518	// This copy assignment will always produce a correct red-black-tree assuming the incoming tree is correct, since our
		1519	// own tree is a red-black-tree and the incoming tree is a red-black-tree. The invariants of a red-black-tree are
		1520	// temporarily not met until all of the incoming red-black tree is copied.
		1521	#ifdef _LIBCPP_COMPILER_CLANG_BASED // FIXME: GCC complains about not being able to always_inline a recursive function
		1522	_LIBCPP_HIDE_FROM_ABI
		1523	#endif
		1524	__node_pointer __assign_from_tree(
		1525	__node_pointer __dest, __node_pointer __src, _Assignment __assign, _ConstructionAlg __construct_subtree) {
		1526	if (!__src) {
		1527	destroy(__dest);
		1528	return nullptr;
1210	}	1529	}
1211		1530
1212	_LIBCPP_HIDE_FROM_ABI ~_DetachedTreeCache() {	1531	__assign(__dest->__get_value(), __src->__get_value());
1213	__t_->destroy(__cache_elem_);	1532	__dest->__is_black_ = __src->__is_black_;
1214	if (__cache_root_) {	1533
1215	while (__cache_root_->__parent_ != nullptr)	1534	// If we already have a left node in the destination tree, reuse it and copy-assign recursively
1216	__cache_root_ = static_cast<__node_pointer>(__cache_root_->__parent_);	1535	if (__dest->__left_) {
1217	__t_->destroy(__cache_root_);	1536	__dest->__left_ = static_cast<__node_base_pointer>(__assign_from_tree(
1218	}	1537	static_cast<__node_pointer>(__dest->__left_),
		1538	static_cast<__node_pointer>(__src->__left_),
		1539	__assign,
		1540	__construct_subtree));
		1541
		1542	// Otherwise, we must create new nodes; copy-construct from here on
		1543	} else if (__src->__left_) {
		1544	auto __new_left = __construct_subtree(static_cast<__node_pointer>(__src->__left_));
		1545	__dest->__left_ = static_cast<__node_base_pointer>(__new_left);
		1546	__new_left->__parent_ = static_cast<__end_node_pointer>(__dest);
1219	}	1547	}
1220		1548
1221	_DetachedTreeCache(_DetachedTreeCache const&) = delete;	1549	// Identical to the left case above, just for the right nodes
1222	_DetachedTreeCache& operator=(_DetachedTreeCache const&) = delete;	1550	if (__dest->__right_) {
		1551	__dest->__right_ = static_cast<__node_base_pointer>(__assign_from_tree(
		1552	static_cast<__node_pointer>(__dest->__right_),
		1553	static_cast<__node_pointer>(__src->__right_),
		1554	__assign,
		1555	__construct_subtree));
		1556	} else if (__src->__right_) {
		1557	auto __new_right = __construct_subtree(static_cast<__node_pointer>(__src->__right_));
		1558	__dest->__right_ = static_cast<__node_base_pointer>(__new_right);
		1559	__new_right->__parent_ = static_cast<__end_node_pointer>(__dest);
		1560	}
1223		1561
1224	private:	1562	return __dest;
1225	_LIBCPP_HIDE_FROM_ABI static __node_pointer __detach_from_tree(__tree* __t) _NOEXCEPT;	1563	}
1226	_LIBCPP_HIDE_FROM_ABI static __node_pointer __detach_next(__node_pointer) _NOEXCEPT;
1227		1564
1228	__tree* __t_;	1565	_LIBCPP_HIDE_FROM_ABI __node_pointer __copy_assign_tree(__node_pointer __dest, __node_pointer __src) {
1229	__node_pointer __cache_root_;	1566	return __assign_from_tree(
1230	__node_pointer __cache_elem_;	1567	__dest,
1231	};	1568	__src,
1232	};	1569	[](value_type& __lhs, const value_type& __rhs) { __assign_value(__lhs, __rhs); },
		1570	[this](__node_pointer __nd) { return __copy_construct_tree(__nd); });
		1571	}
1233		1572
1234	template <class _Tp, class _Compare, class _Allocator>	1573	_LIBCPP_HIDE_FROM_ABI __node_pointer __move_assign_tree(__node_pointer __dest, __node_pointer __src) {
1235	__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp) _NOEXCEPT_(	1574	return __assign_from_tree(
1236	is_nothrow_default_constructible<__node_allocator>::value&& is_nothrow_copy_constructible<value_compare>::value)	1575	__dest,
1237	: __size_(0), __value_comp_(__comp) {	1576	__src,
1238	__begin_node() = __end_node();	1577	[](value_type& __lhs, value_type& __rhs) { __assign_value(__lhs, std::move(__rhs)); },
1239	}	1578	[this](__node_pointer __nd) { return __move_construct_tree(__nd); });
		1579	}
1240		1580
1241	template <class _Tp, class _Compare, class _Allocator>	1581	friend struct __specialized_algorithm<_Algorithm::__for_each, __single_range<__tree> >;
1242	__tree<_Tp, _Compare, _Allocator>::__tree(const allocator_type& __a)	1582	};
1243	: __begin_node_(), __node_alloc_(__node_allocator(__a)), __size_(0) {
1244	__begin_node() = __end_node();
1245	}
1246		1583
		1584	#if _LIBCPP_STD_VER >= 14
1247	template <class _Tp, class _Compare, class _Allocator>	1585	template <class _Tp, class _Compare, class _Allocator>
1248	__tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp, const allocator_type& __a)	1586	struct __specialized_algorithm<_Algorithm::__for_each, __single_range<__tree<_Tp, _Compare, _Allocator> > > {
1249	: __begin_node_(), __node_alloc_(__node_allocator(__a)), __size_(0), __value_comp_(__comp) {	1587	static const bool __has_algorithm = true;
1250	__begin_node() = __end_node();
1251	}
1252		1588
1253	// Precondition: size() != 0	1589	using __node_pointer _LIBCPP_NODEBUG = typename __tree<_Tp, _Compare, _Allocator>::__node_pointer;
1254	template <class _Tp, class _Compare, class _Allocator>
1255	typename __tree<_Tp, _Compare, _Allocator>::__node_pointer
1256	__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_from_tree(__tree* __t) _NOEXCEPT {
1257	__node_pointer __cache = static_cast<__node_pointer>(__t->__begin_node());
1258	__t->__begin_node() = __t->__end_node();
1259	__t->__end_node()->__left_->__parent_ = nullptr;
1260	__t->__end_node()->__left_ = nullptr;
1261	__t->size() = 0;
1262	// __cache->__left_ == nullptr
1263	if (__cache->__right_ != nullptr)
1264	__cache = static_cast<__node_pointer>(__cache->__right_);
1265	// __cache->__left_ == nullptr
1266	// __cache->__right_ == nullptr
1267	return __cache;
1268	}
1269		1590
1270	// Precondition: __cache != nullptr	1591	template <class _Tree, class _Func, class _Proj>
1271	// __cache->left_ == nullptr	1592	_LIBCPP_HIDE_FROM_ABI static auto operator()(_Tree&& __range, _Func __func, _Proj __proj) {
1272	// __cache->right_ == nullptr	1593	if (__range.size() != 0)
1273	// This is no longer a red-black tree	1594	std::__tree_iterate_from_root<__copy_cvref_t<_Tree, typename __remove_cvref_t<_Tree>::value_type>>(
1274	template <class _Tp, class _Compare, class _Allocator>	1595	[](__node_pointer) { return false; }, __range.__root(), __func, __proj);
1275	typename __tree<_Tp, _Compare, _Allocator>::__node_pointer	1596	return std::make_pair(__range.end(), std::move(__func));
1276	__tree<_Tp, _Compare, _Allocator>::_DetachedTreeCache::__detach_next(__node_pointer __cache) _NOEXCEPT {	1597	}
1277	if (__cache->__parent_ == nullptr)	1598	};
1278	return nullptr;	1599	#endif
1279	if (std::__tree_is_left_child(static_cast<__node_base_pointer>(__cache))) {
1280	__cache->__parent_->__left_ = nullptr;
1281	__cache = static_cast<__node_pointer>(__cache->__parent_);
1282	if (__cache->__right_ == nullptr)
1283	return __cache;
1284	return static_cast<__node_pointer>(std::__tree_leaf(__cache->__right_));
1285	}
1286	// __cache is right child
1287	__cache->__parent_unsafe()->__right_ = nullptr;
1288	__cache = static_cast<__node_pointer>(__cache->__parent_);
1289	if (__cache->__left_ == nullptr)
1290	return __cache;
1291	return static_cast<__node_pointer>(std::__tree_leaf(__cache->__left_));
1292	}
1293		1600
1294	template <class _Tp, class _Compare, class _Allocator>	1601	template <class _Tp, class _Compare, class _Allocator>
1295	__tree<_Tp, _Compare, _Allocator>& __tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t) {	1602	__tree<_Tp, _Compare, _Allocator>& __tree<_Tp, _Compare, _Allocator>::operator=(const __tree& __t) {
1296	if (this != std::addressof(__t)) {	1603	if (this == std::addressof(__t))
1297	value_comp() = __t.value_comp();	1604	return *this;
1298	__copy_assign_alloc(__t);
1299	__assign_multi(__t.begin(), __t.end());
1300	}
1301	return *this;
1302	}
1303		1605
1304	template <class _Tp, class _Compare, class _Allocator>	1606	value_comp() = __t.value_comp();
1305	template <class _ForwardIterator>	1607	__copy_assign_alloc(__t);
1306	void __tree<_Tp, _Compare, _Allocator>::__assign_unique(_ForwardIterator __first, _ForwardIterator __last) {
1307	typedef iterator_traits<_ForwardIterator> _ITraits;
1308	typedef typename _ITraits::value_type _ItValueType;
1309	static_assert(
1310	is_same<_ItValueType, value_type>::value, "__assign_unique may only be called with the containers value type");
1311	static_assert(
1312	__has_forward_iterator_category<_ForwardIterator>::value, "__assign_unique requires a forward iterator");
1313	if (size() != 0) {
1314	_DetachedTreeCache __cache(this);
1315	for (; __cache.__get() != nullptr && __first != __last; ++__first) {
1316	if (__node_assign_unique(*__first, __cache.__get()).second)
1317	__cache.__advance();
1318	}
1319	}
1320	for (; __first != __last; ++__first)
1321	__emplace_unique(*__first);
1322	}
1323		1608
1324	template <class _Tp, class _Compare, class _Allocator>	1609	if (__size_ != 0) {
1325	template <class _InputIterator>	1610	*__root_ptr() = static_cast<__node_base_pointer>(__copy_assign_tree(__root(), __t.__root()));
1326	void __tree<_Tp, _Compare, _Allocator>::__assign_multi(_InputIterator __first, _InputIterator __last) {	1611	} else {
1327	typedef iterator_traits<_InputIterator> _ITraits;	1612	*__root_ptr() = static_cast<__node_base_pointer>(__copy_construct_tree(__t.__root()));
1328	typedef typename _ITraits::value_type _ItValueType;	1613	if (__root())
1329	static_assert(	1614	__root()->__parent_ = __end_node();
1330	is_same<_ItValueType, value_type>::value, "__assign_multi may only be called with the containers value_type");
1331	if (size() != 0) {
1332	_DetachedTreeCache __cache(this);
1333	for (; __cache.__get() && __first != __last; ++__first) {
1334	__assign_value(__cache.__get()->__value_, *__first);
1335	__node_insert_multi(__cache.__get());
1336	__cache.__advance();
1337	}
1338	}	1615	}
1339	const_iterator __e = end();	1616	__begin_node_ =
1340	for (; __first != __last; ++__first)	1617	__end_node()->__left_ ? static_cast<__end_node_pointer>(std::__tree_min(__end_node()->__left_)) : __end_node();
1341	__emplace_hint_multi(__e, *__first);	1618	__size_ = __t.size();
		1619
		1620	return *this;
1342	}	1621	}
1343		1622
1344	template <class _Tp, class _Compare, class _Allocator>	1623	template <class _Tp, class _Compare, class _Allocator>
1345	__tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)	1624	__tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)
1346	: __begin_node_(),	1625	: __begin_node_(__end_node()),
1347	__node_alloc_(__node_traits::select_on_container_copy_construction(__t.__node_alloc())),	1626	__node_alloc_(__node_traits::select_on_container_copy_construction(__t.__node_alloc())),
1348	__size_(0),	1627	__size_(0),
1349	__value_comp_(__t.value_comp()) {	1628	__value_comp_(__t.value_comp()) {
1350	__begin_node() = __end_node();	1629	if (__t.size() == 0)
		1630	return;
		1631
		1632	*__root_ptr() = static_cast<__node_base_pointer>(__copy_construct_tree(__t.__root()));
		1633	__root()->__parent_ = __end_node();
		1634	__begin_node_ = static_cast<__end_node_pointer>(std::__tree_min(__end_node()->__left_));
		1635	__size_ = __t.size();
1351	}	1636	}
1352		1637
1353	template <class _Tp, class _Compare, class _Allocator>	1638	template <class _Tp, class _Compare, class _Allocator>
...	@@ -1358,33 +1643,38 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t) _NOEXCEPT_(	...	@@ -1358,33 +1643,38 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t) _NOEXCEPT_(
1358	__node_alloc_(std::move(__t.__node_alloc_)),	1643	__node_alloc_(std::move(__t.__node_alloc_)),
1359	__size_(__t.__size_),	1644	__size_(__t.__size_),
1360	__value_comp_(std::move(__t.__value_comp_)) {	1645	__value_comp_(std::move(__t.__value_comp_)) {
1361	if (size() == 0)	1646	if (__size_ == 0)
1362	__begin_node() = __end_node();	1647	__begin_node_ = __end_node();
1363	else {	1648	else {
1364	__end_node()->__left_->__parent_ = static_cast<__end_node_pointer>(__end_node());	1649	__end_node()->__left_->__parent_ = static_cast<__end_node_pointer>(__end_node());
1365	__t.__begin_node() = __t.__end_node();	1650	__t.__begin_node_ = __t.__end_node();
1366	__t.__end_node()->__left_ = nullptr;	1651	__t.__end_node()->__left_ = nullptr;
1367	__t.size() = 0;	1652	__t.__size_ = 0;
1368	}	1653	}
1369	}	1654	}
1370		1655
1371	template <class _Tp, class _Compare, class _Allocator>	1656	template <class _Tp, class _Compare, class _Allocator>
1372	__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)	1657	__tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
1373	: __node_alloc_(__node_allocator(__a)), __size_(0), __value_comp_(std::move(__t.value_comp())) {	1658	: __begin_node_(__end_node()),
		1659	__node_alloc_(__node_allocator(__a)),
		1660	__size_(0),
		1661	__value_comp_(std::move(__t.value_comp())) {
		1662	if (__t.size() == 0)
		1663	return;
1374	if (__a == __t.__alloc()) {	1664	if (__a == __t.__alloc()) {
1375	if (__t.size() == 0)	1665	__begin_node_ = __t.__begin_node_;
1376	__begin_node() = __end_node();	1666	__end_node()->__left_ = __t.__end_node()->__left_;
1377	else {	1667	__end_node()->__left_->__parent_ = static_cast<__end_node_pointer>(__end_node());
1378	__begin_node() = __t.__begin_node();	1668	__size_ = __t.__size_;
1379	__end_node()->__left_ = __t.__end_node()->__left_;	1669	__t.__begin_node_ = __t.__end_node();
1380	__end_node()->__left_->__parent_ = static_cast<__end_node_pointer>(__end_node());	1670	__t.__end_node()->__left_ = nullptr;
1381	size() = __t.size();	1671	__t.__size_ = 0;
1382	__t.__begin_node() = __t.__end_node();
1383	__t.__end_node()->__left_ = nullptr;
1384	__t.size() = 0;
1385	}
1386	} else {	1672	} else {
1387	__begin_node() = __end_node();	1673	*__root_ptr() = static_cast<__node_base_pointer>(__move_construct_tree(__t.__root()));
		1674	__root()->__parent_ = __end_node();
		1675	__begin_node_ = static_cast<__end_node_pointer>(std::__tree_min(__end_node()->__left_));
		1676	__size_ = __t.size();
		1677	__t.clear(); // Ensure that __t is in a valid state after moving out the keys
1388	}	1678	}
1389	}	1679	}
1390		1680
...	@@ -1397,61 +1687,33 @@ void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)	...	@@ -1397,61 +1687,33 @@ void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
1397	__move_assign_alloc(__t);	1687	__move_assign_alloc(__t);
1398	__size_ = __t.__size_;	1688	__size_ = __t.__size_;
1399	__value_comp_ = std::move(__t.__value_comp_);	1689	__value_comp_ = std::move(__t.__value_comp_);
1400	if (size() == 0)	1690	if (__size_ == 0)
1401	__begin_node() = __end_node();	1691	__begin_node_ = __end_node();
1402	else {	1692	else {
1403	__end_node()->__left_->__parent_ = static_cast<__end_node_pointer>(__end_node());	1693	__end_node()->__left_->__parent_ = static_cast<__end_node_pointer>(__end_node());
1404	__t.__begin_node() = __t.__end_node();	1694	__t.__begin_node_ = __t.__end_node();
1405	__t.__end_node()->__left_ = nullptr;	1695	__t.__end_node()->__left_ = nullptr;
1406	__t.size() = 0;	1696	__t.__size_ = 0;
1407	}	1697	}
1408	}	1698	}
1409		1699
1410	template <class _Tp, class _Compare, class _Allocator>	1700	template <class _Tp, class _Compare, class _Allocator>
1411	void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type) {	1701	void __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type) {
1412	if (__node_alloc() == __t.__node_alloc())	1702	if (__node_alloc() == __t.__node_alloc()) {
1413	__move_assign(__t, true_type());	1703	__move_assign(__t, true_type());
1414	else {	1704	} else {
1415	value_comp() = std::move(__t.value_comp());	1705	value_comp() = std::move(__t.value_comp());
1416	const_iterator __e = end();	1706	if (__size_ != 0) {
1417	if (size() != 0) {	1707	*__root_ptr() = static_cast<__node_base_pointer>(__move_assign_tree(__root(), __t.__root()));
1418	_DetachedTreeCache __cache(this);	1708	} else {
1419	while (__cache.__get() != nullptr && __t.size() != 0) {	1709	*__root_ptr() = static_cast<__node_base_pointer>(__move_construct_tree(__t.__root()));
1420	__assign_value(__cache.__get()->__value_, std::move(__t.remove(__t.begin())->__value_));	1710	if (__root())
1421	__node_insert_multi(__cache.__get());	1711	__root()->__parent_ = __end_node();
1422	__cache.__advance();
1423	}
1424	}
1425	while (__t.size() != 0) {
1426	__insert_multi_from_orphaned_node(__e, std::move(__t.remove(__t.begin())->__value_));
1427	}	1712	}
1428	}	1713	__begin_node_ =
1429	}	1714	__end_node()->__left_ ? static_cast<__end_node_pointer>(std::__tree_min(__end_node()->__left_)) : __end_node();
1430		1715	__size_ = __t.size();
1431	template <class _Tp, class _Compare, class _Allocator>	1716	__t.clear(); // Ensure that __t is in a valid state after moving out the keys
1432	__tree<_Tp, _Compare, _Allocator>& __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
1433	_NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
1434	((__node_traits::propagate_on_container_move_assignment::value &&
1435	is_nothrow_move_assignable<__node_allocator>::value) \|\|
1436	allocator_traits<__node_allocator>::is_always_equal::value)) {
1437	__move_assign(__t, integral_constant<bool, __node_traits::propagate_on_container_move_assignment::value>());
1438	return *this;
1439	}
1440
1441	template <class _Tp, class _Compare, class _Allocator>
1442	__tree<_Tp, _Compare, _Allocator>::~__tree() {
1443	static_assert(is_copy_constructible<value_compare>::value, "Comparator must be copy-constructible.");
1444	destroy(__root());
1445	}
1446
1447	template <class _Tp, class _Compare, class _Allocator>
1448	void __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT {
1449	if (__nd != nullptr) {
1450	destroy(static_cast<__node_pointer>(__nd->__left_));
1451	destroy(static_cast<__node_pointer>(__nd->__right_));
1452	__node_allocator& __na = __node_alloc();
1453	__node_traits::destroy(__na, std::addressof(__nd->__value_));
1454	__node_traits::deallocate(__na, __nd, 1);
1455	}	1717	}
1456	}	1718	}
1457		1719
...	@@ -1470,12 +1732,12 @@ void __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)	...	@@ -1470,12 +1732,12 @@ void __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
1470	std::__swap_allocator(__node_alloc(), __t.__node_alloc());	1732	std::__swap_allocator(__node_alloc(), __t.__node_alloc());
1471	swap(__size_, __t.__size_);	1733	swap(__size_, __t.__size_);
1472	swap(__value_comp_, __t.__value_comp_);	1734	swap(__value_comp_, __t.__value_comp_);
1473	if (size() == 0)	1735	if (__size_ == 0)
1474	__begin_node() = __end_node();	1736	__begin_node_ = __end_node();
1475	else	1737	else
1476	__end_node()->__left_->__parent_ = __end_node();	1738	__end_node()->__left_->__parent_ = __end_node();
1477	if (__t.size() == 0)	1739	if (__t.__size_ == 0)
1478	__t.__begin_node() = __t.__end_node();	1740	__t.__begin_node_ = __t.__end_node();
1479	else	1741	else
1480	__t.__end_node()->__left_->__parent_ = __t.__end_node();	1742	__t.__end_node()->__left_->__parent_ = __t.__end_node();
1481	}	1743	}
...	@@ -1483,8 +1745,8 @@ void __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)	...	@@ -1483,8 +1745,8 @@ void __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
1483	template <class _Tp, class _Compare, class _Allocator>	1745	template <class _Tp, class _Compare, class _Allocator>
1484	void __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT {	1746	void __tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT {
1485	destroy(__root());	1747	destroy(__root());
1486	size() = 0;	1748	__size_ = 0;
1487	__begin_node() = __end_node();	1749	__begin_node_ = __end_node();
1488	__end_node()->__left_ = nullptr;	1750	__end_node()->__left_ = nullptr;
1489	}	1751	}
1490		1752
...	@@ -1497,7 +1759,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__end_node_pointer& __parent,	...	@@ -1497,7 +1759,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(__end_node_pointer& __parent,
1497	__node_pointer __nd = __root();	1759	__node_pointer __nd = __root();
1498	if (__nd != nullptr) {	1760	if (__nd != nullptr) {
1499	while (true) {	1761	while (true) {
1500	if (value_comp()(__nd->__value_, __v)) {	1762	if (value_comp()(__nd->__get_value(), __v)) {
1501	if (__nd->__right_ != nullptr)	1763	if (__nd->__right_ != nullptr)
1502	__nd = static_cast<__node_pointer>(__nd->__right_);	1764	__nd = static_cast<__node_pointer>(__nd->__right_);
1503	else {	1765	else {
...	@@ -1527,7 +1789,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__end_node_pointer& __parent	...	@@ -1527,7 +1789,7 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(__end_node_pointer& __parent
1527	__node_pointer __nd = __root();	1789	__node_pointer __nd = __root();
1528	if (__nd != nullptr) {	1790	if (__nd != nullptr) {
1529	while (true) {	1791	while (true) {
1530	if (value_comp()(__v, __nd->__value_)) {	1792	if (value_comp()(__v, __nd->__get_value())) {
1531	if (__nd->__left_ != nullptr)	1793	if (__nd->__left_ != nullptr)
1532	__nd = static_cast<__node_pointer>(__nd->__left_);	1794	__nd = static_cast<__node_pointer>(__nd->__left_);
1533	else {	1795	else {
...	@@ -1578,92 +1840,91 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer& __tree<_Tp, _Co	...	@@ -1578,92 +1840,91 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer& __tree<_Tp, _Co
1578	return __find_leaf_low(__parent, __v);	1840	return __find_leaf_low(__parent, __v);
1579	}	1841	}
1580		1842
1581	// Find place to insert if __v doesn't exist	1843	// Find __v
1582	// Set __parent to parent of null leaf	1844	// If __v exists, return the parent of the node of __v and a reference to the pointer to the node of __v.
1583	// Return reference to null leaf	1845	// If __v doesn't exist, return the parent of the null leaf and a reference to the pointer to the null leaf.
1584	// If __v exists, set parent to node of __v and return reference to node of __v
1585	template <class _Tp, class _Compare, class _Allocator>	1846	template <class _Tp, class _Compare, class _Allocator>
1586	template <class _Key>	1847	template <class _Key>
1587	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&	1848	_LIBCPP_HIDE_FROM_ABI pair<typename __tree<_Tp, _Compare, _Allocator>::__end_node_pointer,
1588	__tree<_Tp, _Compare, _Allocator>::__find_equal(__end_node_pointer& __parent, const _Key& __v) {	1849	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&>
1589	__node_pointer __nd = __root();	1850	__tree<_Tp, _Compare, _Allocator>::__find_equal(const _Key& __v) {
1590	__node_base_pointer* __nd_ptr = __root_ptr();	1851	using _Pair = pair<__end_node_pointer, __node_base_pointer&>;
1591	if (__nd != nullptr) {	1852
1592	while (true) {	1853	__node_pointer __nd = __root();
1593	if (value_comp()(__v, __nd->__value_)) {	1854
1594	if (__nd->__left_ != nullptr) {	1855	if (__nd == nullptr) {
1595	__nd_ptr = std::addressof(__nd->__left_);	1856	auto __end = __end_node();
1596	__nd = static_cast<__node_pointer>(__nd->__left_);	1857	return _Pair(__end, __end->__left_);
1597	} else {	1858	}
1598	__parent = static_cast<__end_node_pointer>(__nd);	1859
1599	return __parent->__left_;	1860	__node_base_pointer* __node_ptr = __root_ptr();
1600	}	1861	auto&& __transparent = std::__as_transparent<_Key>(value_comp());
1601	} else if (value_comp()(__nd->__value_, __v)) {	1862	auto __comp =
1602	if (__nd->__right_ != nullptr) {	1863	__lazy_synth_three_way_comparator<__make_transparent_t<_Key, _Compare>, _Key, value_type>(__transparent);
1603	__nd_ptr = std::addressof(__nd->__right_);	1864
1604	__nd = static_cast<__node_pointer>(__nd->__right_);	1865	while (true) {
1605	} else {	1866	auto __comp_res = __comp(__v, __nd->__get_value());
1606	__parent = static_cast<__end_node_pointer>(__nd);	1867
1607	return __nd->__right_;	1868	if (__comp_res.__less()) {
1608	}	1869	if (__nd->__left_ == nullptr)
1609	} else {	1870	return _Pair(static_cast<__end_node_pointer>(__nd), __nd->__left_);
1610	__parent = static_cast<__end_node_pointer>(__nd);	1871
1611	return *__nd_ptr;	1872	__node_ptr = std::addressof(__nd->__left_);
1612	}	1873	__nd = static_cast<__node_pointer>(__nd->__left_);
		1874	} else if (__comp_res.__greater()) {
		1875	if (__nd->__right_ == nullptr)
		1876	return _Pair(static_cast<__end_node_pointer>(__nd), __nd->__right_);
		1877
		1878	__node_ptr = std::addressof(__nd->__right_);
		1879	__nd = static_cast<__node_pointer>(__nd->__right_);
		1880	} else {
		1881	return _Pair(static_cast<__end_node_pointer>(__nd), *__node_ptr);
1613	}	1882	}
1614	}	1883	}
1615	__parent = __end_node();
1616	return __parent->__left_;
1617	}	1884	}
1618		1885
1619	// Find place to insert if __v doesn't exist	1886	// Find __v
1620	// First check prior to __hint.	1887	// First check prior to __hint.
1621	// Next check after __hint.	1888	// Next check after __hint.
1622	// Next do O(log N) search.	1889	// Next do O(log N) search.
1623	// Set __parent to parent of null leaf	1890	// If __v exists, return the parent of the node of __v and a reference to the pointer to the node of __v.
1624	// Return reference to null leaf	1891	// If __v doesn't exist, return the parent of the null leaf and a reference to the pointer to the null leaf.
1625	// If __v exists, set parent to node of __v and return reference to node of __v
1626	template <class _Tp, class _Compare, class _Allocator>	1892	template <class _Tp, class _Compare, class _Allocator>
1627	template <class _Key>	1893	template <class _Key>
1628	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer& __tree<_Tp, _Compare, _Allocator>::__find_equal(	1894	_LIBCPP_HIDE_FROM_ABI pair<typename __tree<_Tp, _Compare, _Allocator>::__end_node_pointer,
1629	const_iterator __hint, __end_node_pointer& __parent, __node_base_pointer& __dummy, const _Key& __v) {	1895	typename __tree<_Tp, _Compare, _Allocator>::__node_base_pointer&>
1630	if (__hint == end() \|\| value_comp()(__v, *__hint)) // check before	1896	__tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint, __node_base_pointer& __dummy, const _Key& __v) {
1631	{	1897	using _Pair = pair<__end_node_pointer, __node_base_pointer&>;
		1898
		1899	if (__hint == end() \|\| value_comp()(__v, *__hint)) { // check before
1632	// __v < *__hint	1900	// __v < *__hint
1633	const_iterator __prior = __hint;	1901	const_iterator __prior = __hint;
1634	if (__prior == begin() \|\| value_comp()(*--__prior, __v)) {	1902	if (__prior == begin() \|\| value_comp()(*--__prior, __v)) {
1635	// prev(__hint) < __v < __hint	1903	// prev(__hint) < __v < __hint
1636	if (__hint.__ptr_->__left_ == nullptr) {	1904	if (__hint.__ptr_->__left_ == nullptr)
1637	__parent = __hint.__ptr_;	1905	return _Pair(__hint.__ptr_, __hint.__ptr_->__left_);
1638	return __parent->__left_;	1906	return _Pair(__prior.__ptr_, static_cast<__node_pointer>(__prior.__ptr_)->__right_);
1639	} else {
1640	__parent = __prior.__ptr_;
1641	return static_cast<__node_base_pointer>(__prior.__ptr_)->__right_;
1642	}
1643	}	1907	}
1644	// __v <= *prev(__hint)	1908	// __v <= *prev(__hint)
1645	return __find_equal(__parent, __v);	1909	return __find_equal(__v);
1646	} else if (value_comp()(*__hint, __v)) // check after	1910	}
1647	{	1911
		1912	if (value_comp()(*__hint, __v)) { // check after
1648	// *__hint < __v	1913	// *__hint < __v
1649	const_iterator __next = std::next(__hint);	1914	const_iterator __next = std::next(__hint);
1650	if (__next == end() \|\| value_comp()(__v, *__next)) {	1915	if (__next == end() \|\| value_comp()(__v, *__next)) {
1651	// __hint < __v < std::next(__hint)	1916	// __hint < __v < std::next(__hint)
1652	if (__hint.__get_np()->__right_ == nullptr) {	1917	if (__hint.__get_np()->__right_ == nullptr)
1653	__parent = __hint.__ptr_;	1918	return _Pair(__hint.__ptr_, static_cast<__node_pointer>(__hint.__ptr_)->__right_);
1654	return static_cast<__node_base_pointer>(__hint.__ptr_)->__right_;	1919	return _Pair(__next.__ptr_, __next.__ptr_->__left_);
1655	} else {
1656	__parent = __next.__ptr_;
1657	return __parent->__left_;
1658	}
1659	}	1920	}
1660	// *next(__hint) <= __v	1921	// *next(__hint) <= __v
1661	return __find_equal(__parent, __v);	1922	return __find_equal(__v);
1662	}	1923	}
		1924
1663	// else __v == *__hint	1925	// else __v == *__hint
1664	__parent = __hint.__ptr_;	1926	__dummy = static_cast<__node_base_pointer>(__hint.__ptr_);
1665	__dummy = static_cast<__node_base_pointer>(__hint.__ptr_);	1927	return _Pair(__hint.__ptr_, __dummy);
1666	return __dummy;
1667	}	1928	}
1668		1929
1669	template <class _Tp, class _Compare, class _Allocator>	1930	template <class _Tp, class _Compare, class _Allocator>
...	@@ -1674,46 +1935,10 @@ void __tree<_Tp, _Compare, _Allocator>::__insert_node_at(	...	@@ -1674,46 +1935,10 @@ void __tree<_Tp, _Compare, _Allocator>::__insert_node_at(
1674	__new_node->__parent_ = __parent;	1935	__new_node->__parent_ = __parent;
1675	// __new_node->__is_black_ is initialized in __tree_balance_after_insert	1936	// __new_node->__is_black_ is initialized in __tree_balance_after_insert
1676	__child = __new_node;	1937	__child = __new_node;
1677	if (__begin_node()->__left_ != nullptr)	1938	if (__begin_node_->__left_ != nullptr)
1678	__begin_node() = static_cast<__end_node_pointer>(__begin_node()->__left_);	1939	__begin_node_ = static_cast<__end_node_pointer>(__begin_node_->__left_);
1679	std::__tree_balance_after_insert(__end_node()->__left_, __child);	1940	std::__tree_balance_after_insert(__end_node()->__left_, __child);
1680	++size();	1941	++__size_;
1681	}
1682
1683	template <class _Tp, class _Compare, class _Allocator>
1684	template <class _Key, class... _Args>
1685	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
1686	__tree<_Tp, _Compare, _Allocator>::__emplace_unique_key_args(_Key const& __k, _Args&&... __args) {
1687	__end_node_pointer __parent;
1688	__node_base_pointer& __child = __find_equal(__parent, __k);
1689	__node_pointer __r = static_cast<__node_pointer>(__child);
1690	bool __inserted = false;
1691	if (__child == nullptr) {
1692	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1693	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1694	__r = __h.release();
1695	__inserted = true;
1696	}
1697	return pair<iterator, bool>(iterator(__r), __inserted);
1698	}
1699
1700	template <class _Tp, class _Compare, class _Allocator>
1701	template <class _Key, class... _Args>
1702	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
1703	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_key_args(
1704	const_iterator __p, _Key const& __k, _Args&&... __args) {
1705	__end_node_pointer __parent;
1706	__node_base_pointer __dummy;
1707	__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __k);
1708	__node_pointer __r = static_cast<__node_pointer>(__child);
1709	bool __inserted = false;
1710	if (__child == nullptr) {
1711	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1712	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1713	__r = __h.release();
1714	__inserted = true;
1715	}
1716	return pair<iterator, bool>(iterator(__r), __inserted);
1717	}	1942	}
1718		1943
1719	template <class _Tp, class _Compare, class _Allocator>	1944	template <class _Tp, class _Compare, class _Allocator>
...	@@ -1722,51 +1947,18 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_holder	...	@@ -1722,51 +1947,18 @@ typename __tree<_Tp, _Compare, _Allocator>::__node_holder
1722	__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&&... __args) {	1947	__tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&&... __args) {
1723	__node_allocator& __na = __node_alloc();	1948	__node_allocator& __na = __node_alloc();
1724	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));	1949	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
1725	__node_traits::construct(__na, std::addressof(__h->__value_), std::forward<_Args>(__args)...);	1950	std::__construct_at(std::addressof(*__h), __na, std::forward<_Args>(__args)...);
1726	__h.get_deleter().__value_constructed = true;	1951	__h.get_deleter().__value_constructed = true;
1727	return __h;	1952	return __h;
1728	}	1953	}
1729		1954
1730	template <class _Tp, class _Compare, class _Allocator>
1731	template <class... _Args>
1732	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
1733	__tree<_Tp, _Compare, _Allocator>::__emplace_unique_impl(_Args&&... __args) {
1734	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1735	__end_node_pointer __parent;
1736	__node_base_pointer& __child = __find_equal(__parent, __h->__value_);
1737	__node_pointer __r = static_cast<__node_pointer>(__child);
1738	bool __inserted = false;
1739	if (__child == nullptr) {
1740	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1741	__r = __h.release();
1742	__inserted = true;
1743	}
1744	return pair<iterator, bool>(iterator(__r), __inserted);
1745	}
1746
1747	template <class _Tp, class _Compare, class _Allocator>
1748	template <class... _Args>
1749	typename __tree<_Tp, _Compare, _Allocator>::iterator
1750	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique_impl(const_iterator __p, _Args&&... __args) {
1751	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1752	__end_node_pointer __parent;
1753	__node_base_pointer __dummy;
1754	__node_base_pointer& __child = __find_equal(__p, __parent, __dummy, __h->__value_);
1755	__node_pointer __r = static_cast<__node_pointer>(__child);
1756	if (__child == nullptr) {
1757	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1758	__r = __h.release();
1759	}
1760	return iterator(__r);
1761	}
1762
1763	template <class _Tp, class _Compare, class _Allocator>	1955	template <class _Tp, class _Compare, class _Allocator>
1764	template <class... _Args>	1956	template <class... _Args>
1765	typename __tree<_Tp, _Compare, _Allocator>::iterator	1957	typename __tree<_Tp, _Compare, _Allocator>::iterator
1766	__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) {	1958	__tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args) {
1767	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);	1959	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1768	__end_node_pointer __parent;	1960	__end_node_pointer __parent;
1769	__node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);	1961	__node_base_pointer& __child = __find_leaf_high(__parent, __h->__get_value());
1770	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));	1962	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1771	return iterator(static_cast<__node_pointer>(__h.release()));	1963	return iterator(static_cast<__node_pointer>(__h.release()));
1772	}	1964	}
...	@@ -1777,53 +1969,19 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator	...	@@ -1777,53 +1969,19 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
1777	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) {	1969	__tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p, _Args&&... __args) {
1778	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);	1970	__node_holder __h = __construct_node(std::forward<_Args>(__args)...);
1779	__end_node_pointer __parent;	1971	__end_node_pointer __parent;
1780	__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);	1972	__node_base_pointer& __child = __find_leaf(__p, __parent, __h->__get_value());
1781	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));	1973	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1782	return iterator(static_cast<__node_pointer>(__h.release()));	1974	return iterator(static_cast<__node_pointer>(__h.release()));
1783	}	1975	}
1784		1976
1785	template <class _Tp, class _Compare, class _Allocator>
1786	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
1787	__tree<_Tp, _Compare, _Allocator>::__node_assign_unique(const value_type& __v, __node_pointer __nd) {
1788	__end_node_pointer __parent;
1789	__node_base_pointer& __child = __find_equal(__parent, __v);
1790	__node_pointer __r = static_cast<__node_pointer>(__child);
1791	bool __inserted = false;
1792	if (__child == nullptr) {
1793	__assign_value(__nd->__value_, __v);
1794	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
1795	__r = __nd;
1796	__inserted = true;
1797	}
1798	return pair<iterator, bool>(iterator(__r), __inserted);
1799	}
1800
1801	template <class _Tp, class _Compare, class _Allocator>
1802	typename __tree<_Tp, _Compare, _Allocator>::iterator
1803	__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(__node_pointer __nd) {
1804	__end_node_pointer __parent;
1805	__node_base_pointer& __child = __find_leaf_high(__parent, __nd->__value_);
1806	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
1807	return iterator(__nd);
1808	}
1809
1810	template <class _Tp, class _Compare, class _Allocator>
1811	typename __tree<_Tp, _Compare, _Allocator>::iterator
1812	__tree<_Tp, _Compare, _Allocator>::__node_insert_multi(const_iterator __p, __node_pointer __nd) {
1813	__end_node_pointer __parent;
1814	__node_base_pointer& __child = __find_leaf(__p, __parent, __nd->__value_);
1815	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__nd));
1816	return iterator(__nd);
1817	}
1818
1819	template <class _Tp, class _Compare, class _Allocator>	1977	template <class _Tp, class _Compare, class _Allocator>
1820	typename __tree<_Tp, _Compare, _Allocator>::iterator	1978	typename __tree<_Tp, _Compare, _Allocator>::iterator
1821	__tree<_Tp, _Compare, _Allocator>::__remove_node_pointer(__node_pointer __ptr) _NOEXCEPT {	1979	__tree<_Tp, _Compare, _Allocator>::__remove_node_pointer(__node_pointer __ptr) _NOEXCEPT {
1822	iterator __r(__ptr);	1980	iterator __r(__ptr);
1823	++__r;	1981	++__r;
1824	if (__begin_node() == __ptr)	1982	if (__begin_node_ == __ptr)
1825	__begin_node() = __r.__ptr_;	1983	__begin_node_ = __r.__ptr_;
1826	--size();	1984	--__size_;
1827	std::__tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__ptr));	1985	std::__tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__ptr));
1828	return __r;	1986	return __r;
1829	}	1987	}
...	@@ -1837,8 +1995,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(_NodeHandle&& __n	...	@@ -1837,8 +1995,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(_NodeHandle&& __n
1837	return _InsertReturnType{end(), false, _NodeHandle()};	1995	return _InsertReturnType{end(), false, _NodeHandle()};
1838		1996
1839	__node_pointer __ptr = __nh.__ptr_;	1997	__node_pointer __ptr = __nh.__ptr_;
1840	__end_node_pointer __parent;	1998	auto [__parent, __child] = __find_equal(__ptr->__get_value());
1841	__node_base_pointer& __child = __find_equal(__parent, __ptr->__value_);
1842	if (__child != nullptr)	1999	if (__child != nullptr)
1843	return _InsertReturnType{iterator(static_cast<__node_pointer>(__child)), false, std::move(__nh)};	2000	return _InsertReturnType{iterator(static_cast<__node_pointer>(__child)), false, std::move(__nh)};
1844		2001
...	@@ -1855,10 +2012,9 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(const_iterator __	...	@@ -1855,10 +2012,9 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_unique(const_iterator __
1855	return end();	2012	return end();
1856		2013
1857	__node_pointer __ptr = __nh.__ptr_;	2014	__node_pointer __ptr = __nh.__ptr_;
1858	__end_node_pointer __parent;
1859	__node_base_pointer __dummy;	2015	__node_base_pointer __dummy;
1860	__node_base_pointer& __child = __find_equal(__hint, __parent, __dummy, __ptr->__value_);	2016	auto [__parent, __child] = __find_equal(__hint, __dummy, __ptr->__get_value());
1861	__node_pointer __r = static_cast<__node_pointer>(__child);	2017	__node_pointer __r = static_cast<__node_pointer>(__child);
1862	if (__child == nullptr) {	2018	if (__child == nullptr) {
1863	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));	2019	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
1864	__r = __ptr;	2020	__r = __ptr;
...	@@ -1885,14 +2041,12 @@ _LIBCPP_HIDE_FROM_ABI _NodeHandle __tree<_Tp, _Compare, _Allocator>::__node_hand	...	@@ -1885,14 +2041,12 @@ _LIBCPP_HIDE_FROM_ABI _NodeHandle __tree<_Tp, _Compare, _Allocator>::__node_hand
1885	}	2041	}
1886		2042
1887	template <class _Tp, class _Compare, class _Allocator>	2043	template <class _Tp, class _Compare, class _Allocator>
1888	template <class _Tree>	2044	template <class _Comp2>
1889	_LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merge_unique(_Tree& __source) {	2045	_LIBCPP_HIDE_FROM_ABI void
1890	static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");	2046	__tree<_Tp, _Compare, _Allocator>::__node_handle_merge_unique(__tree<_Tp, _Comp2, _Allocator>& __source) {
1891		2047	for (iterator __i = __source.begin(); __i != __source.end();) {
1892	for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
1893	__node_pointer __src_ptr = __i.__get_np();	2048	__node_pointer __src_ptr = __i.__get_np();
1894	__end_node_pointer __parent;	2049	auto [__parent, __child] = __find_equal(__src_ptr->__get_value());
1895	__node_base_pointer& __child = __find_equal(__parent, __src_ptr->__value_);
1896	++__i;	2050	++__i;
1897	if (__child != nullptr)	2051	if (__child != nullptr)
1898	continue;	2052	continue;
...	@@ -1909,7 +2063,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh	...	@@ -1909,7 +2063,7 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(_NodeHandle&& __nh
1909	return end();	2063	return end();
1910	__node_pointer __ptr = __nh.__ptr_;	2064	__node_pointer __ptr = __nh.__ptr_;
1911	__end_node_pointer __parent;	2065	__end_node_pointer __parent;
1912	__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__value_);	2066	__node_base_pointer& __child = __find_leaf_high(__parent, __ptr->__get_value());
1913	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));	2067	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
1914	__nh.__release_ptr();	2068	__nh.__release_ptr();
1915	return iterator(__ptr);	2069	return iterator(__ptr);
...	@@ -1924,21 +2078,20 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(const_iterator __h	...	@@ -1924,21 +2078,20 @@ __tree<_Tp, _Compare, _Allocator>::__node_handle_insert_multi(const_iterator __h
1924		2078
1925	__node_pointer __ptr = __nh.__ptr_;	2079	__node_pointer __ptr = __nh.__ptr_;
1926	__end_node_pointer __parent;	2080	__end_node_pointer __parent;
1927	__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__value_);	2081	__node_base_pointer& __child = __find_leaf(__hint, __parent, __ptr->__get_value());
1928	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));	2082	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__ptr));
1929	__nh.__release_ptr();	2083	__nh.__release_ptr();
1930	return iterator(__ptr);	2084	return iterator(__ptr);
1931	}	2085	}
1932		2086
1933	template <class _Tp, class _Compare, class _Allocator>	2087	template <class _Tp, class _Compare, class _Allocator>
1934	template <class _Tree>	2088	template <class _Comp2>
1935	_LIBCPP_HIDE_FROM_ABI void __tree<_Tp, _Compare, _Allocator>::__node_handle_merge_multi(_Tree& __source) {	2089	_LIBCPP_HIDE_FROM_ABI void
1936	static_assert(is_same<typename _Tree::__node_pointer, __node_pointer>::value, "");	2090	__tree<_Tp, _Compare, _Allocator>::__node_handle_merge_multi(__tree<_Tp, _Comp2, _Allocator>& __source) {
1937		2091	for (iterator __i = __source.begin(); __i != __source.end();) {
1938	for (typename _Tree::iterator __i = __source.begin(); __i != __source.end();) {
1939	__node_pointer __src_ptr = __i.__get_np();	2092	__node_pointer __src_ptr = __i.__get_np();
1940	__end_node_pointer __parent;	2093	__end_node_pointer __parent;
1941	__node_base_pointer& __child = __find_leaf_high(__parent, __src_ptr->__value_);	2094	__node_base_pointer& __child = __find_leaf_high(__parent, __src_ptr->__get_value());
1942	++__i;	2095	++__i;
1943	__source.__remove_node_pointer(__src_ptr);	2096	__source.__remove_node_pointer(__src_ptr);
1944	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__src_ptr));	2097	__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__src_ptr));
...	@@ -1987,34 +2140,17 @@ __tree<_Tp, _Compare, _Allocator>::__erase_multi(const _Key& __k) {	...	@@ -1987,34 +2140,17 @@ __tree<_Tp, _Compare, _Allocator>::__erase_multi(const _Key& __k) {
1987	return __r;	2140	return __r;
1988	}	2141	}
1989		2142
1990	template <class _Tp, class _Compare, class _Allocator>
1991	template <class _Key>
1992	typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) {
1993	iterator __p = __lower_bound(__v, __root(), __end_node());
1994	if (__p != end() && !value_comp()(__v, *__p))
1995	return __p;
1996	return end();
1997	}
1998
1999	template <class _Tp, class _Compare, class _Allocator>
2000	template <class _Key>
2001	typename __tree<_Tp, _Compare, _Allocator>::const_iterator
2002	__tree<_Tp, _Compare, _Allocator>::find(const _Key& __v) const {
2003	const_iterator __p = __lower_bound(__v, __root(), __end_node());
2004	if (__p != end() && !value_comp()(__v, *__p))
2005	return __p;
2006	return end();
2007	}
2008
2009	template <class _Tp, class _Compare, class _Allocator>	2143	template <class _Tp, class _Compare, class _Allocator>
2010	template <class _Key>	2144	template <class _Key>
2011	typename __tree<_Tp, _Compare, _Allocator>::size_type	2145	typename __tree<_Tp, _Compare, _Allocator>::size_type
2012	__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const {	2146	__tree<_Tp, _Compare, _Allocator>::__count_unique(const _Key& __k) const {
2013	__node_pointer __rt = __root();	2147	__node_pointer __rt = __root();
		2148	auto __comp = __lazy_synth_three_way_comparator<value_compare, _Key, value_type>(value_comp());
2014	while (__rt != nullptr) {	2149	while (__rt != nullptr) {
2015	if (value_comp()(__k, __rt->__value_)) {	2150	auto __comp_res = __comp(__k, __rt->__get_value());
		2151	if (__comp_res.__less()) {
2016	__rt = static_cast<__node_pointer>(__rt->__left_);	2152	__rt = static_cast<__node_pointer>(__rt->__left_);
2017	} else if (value_comp()(__rt->__value_, __k))	2153	} else if (__comp_res.__greater())
2018	__rt = static_cast<__node_pointer>(__rt->__right_);	2154	__rt = static_cast<__node_pointer>(__rt->__right_);
2019	else	2155	else
2020	return 1;	2156	return 1;
...	@@ -2028,26 +2164,28 @@ typename __tree<_Tp, _Compare, _Allocator>::size_type	...	@@ -2028,26 +2164,28 @@ typename __tree<_Tp, _Compare, _Allocator>::size_type
2028	__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const {	2164	__tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const {
2029	__end_node_pointer __result = __end_node();	2165	__end_node_pointer __result = __end_node();
2030	__node_pointer __rt = __root();	2166	__node_pointer __rt = __root();
		2167	auto __comp = __lazy_synth_three_way_comparator<value_compare, _Key, value_type>(value_comp());
2031	while (__rt != nullptr) {	2168	while (__rt != nullptr) {
2032	if (value_comp()(__k, __rt->__value_)) {	2169	auto __comp_res = __comp(__k, __rt->__get_value());
		2170	if (__comp_res.__less()) {
2033	__result = static_cast<__end_node_pointer>(__rt);	2171	__result = static_cast<__end_node_pointer>(__rt);
2034	__rt = static_cast<__node_pointer>(__rt->__left_);	2172	__rt = static_cast<__node_pointer>(__rt->__left_);
2035	} else if (value_comp()(__rt->__value_, __k))	2173	} else if (__comp_res.__greater())
2036	__rt = static_cast<__node_pointer>(__rt->__right_);	2174	__rt = static_cast<__node_pointer>(__rt->__right_);
2037	else	2175	else
2038	return std::distance(	2176	return std::distance(
2039	__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),	2177	__lower_bound_multi(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
2040	__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));	2178	__upper_bound_multi(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2041	}	2179	}
2042	return 0;	2180	return 0;
2043	}	2181	}
2044		2182
2045	template <class _Tp, class _Compare, class _Allocator>	2183	template <class _Tp, class _Compare, class _Allocator>
2046	template <class _Key>	2184	template <class _Key>
2047	typename __tree<_Tp, _Compare, _Allocator>::iterator	2185	typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::__lower_bound_multi(
2048	__tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) {	2186	const _Key& __v, __node_pointer __root, __end_node_pointer __result) {
2049	while (__root != nullptr) {	2187	while (__root != nullptr) {
2050	if (!value_comp()(__root->__value_, __v)) {	2188	if (!value_comp()(__root->__get_value(), __v)) {
2051	__result = static_cast<__end_node_pointer>(__root);	2189	__result = static_cast<__end_node_pointer>(__root);
2052	__root = static_cast<__node_pointer>(__root->__left_);	2190	__root = static_cast<__node_pointer>(__root->__left_);
2053	} else	2191	} else
...	@@ -2058,10 +2196,10 @@ __tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v, __node_pointer	...	@@ -2058,10 +2196,10 @@ __tree<_Tp, _Compare, _Allocator>::__lower_bound(const _Key& __v, __node_pointer
2058		2196
2059	template <class _Tp, class _Compare, class _Allocator>	2197	template <class _Tp, class _Compare, class _Allocator>
2060	template <class _Key>	2198	template <class _Key>
2061	typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__lower_bound(	2199	typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__lower_bound_multi(
2062	const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {	2200	const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {
2063	while (__root != nullptr) {	2201	while (__root != nullptr) {
2064	if (!value_comp()(__root->__value_, __v)) {	2202	if (!value_comp()(__root->__get_value(), __v)) {
2065	__result = static_cast<__end_node_pointer>(__root);	2203	__result = static_cast<__end_node_pointer>(__root);
2066	__root = static_cast<__node_pointer>(__root->__left_);	2204	__root = static_cast<__node_pointer>(__root->__left_);
2067	} else	2205	} else
...	@@ -2072,10 +2210,10 @@ typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare,	...	@@ -2072,10 +2210,10 @@ typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare,
2072		2210
2073	template <class _Tp, class _Compare, class _Allocator>	2211	template <class _Tp, class _Compare, class _Allocator>
2074	template <class _Key>	2212	template <class _Key>
2075	typename __tree<_Tp, _Compare, _Allocator>::iterator	2213	typename __tree<_Tp, _Compare, _Allocator>::iterator __tree<_Tp, _Compare, _Allocator>::__upper_bound_multi(
2076	__tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v, __node_pointer __root, __end_node_pointer __result) {	2214	const _Key& __v, __node_pointer __root, __end_node_pointer __result) {
2077	while (__root != nullptr) {	2215	while (__root != nullptr) {
2078	if (value_comp()(__v, __root->__value_)) {	2216	if (value_comp()(__v, __root->__get_value())) {
2079	__result = static_cast<__end_node_pointer>(__root);	2217	__result = static_cast<__end_node_pointer>(__root);
2080	__root = static_cast<__node_pointer>(__root->__left_);	2218	__root = static_cast<__node_pointer>(__root->__left_);
2081	} else	2219	} else
...	@@ -2086,10 +2224,10 @@ __tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v, __node_pointer	...	@@ -2086,10 +2224,10 @@ __tree<_Tp, _Compare, _Allocator>::__upper_bound(const _Key& __v, __node_pointer
2086		2224
2087	template <class _Tp, class _Compare, class _Allocator>	2225	template <class _Tp, class _Compare, class _Allocator>
2088	template <class _Key>	2226	template <class _Key>
2089	typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__upper_bound(	2227	typename __tree<_Tp, _Compare, _Allocator>::const_iterator __tree<_Tp, _Compare, _Allocator>::__upper_bound_multi(
2090	const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {	2228	const _Key& __v, __node_pointer __root, __end_node_pointer __result) const {
2091	while (__root != nullptr) {	2229	while (__root != nullptr) {
2092	if (value_comp()(__v, __root->__value_)) {	2230	if (value_comp()(__v, __root->__get_value())) {
2093	__result = static_cast<__end_node_pointer>(__root);	2231	__result = static_cast<__end_node_pointer>(__root);
2094	__root = static_cast<__node_pointer>(__root->__left_);	2232	__root = static_cast<__node_pointer>(__root->__left_);
2095	} else	2233	} else
...	@@ -2102,14 +2240,16 @@ template <class _Tp, class _Compare, class _Allocator>	...	@@ -2102,14 +2240,16 @@ template <class _Tp, class _Compare, class _Allocator>
2102	template <class _Key>	2240	template <class _Key>
2103	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, typename __tree<_Tp, _Compare, _Allocator>::iterator>	2241	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, typename __tree<_Tp, _Compare, _Allocator>::iterator>
2104	__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) {	2242	__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) {
2105	typedef pair<iterator, iterator> _Pp;	2243	using _Pp = pair<iterator, iterator>;
2106	__end_node_pointer __result = __end_node();	2244	__end_node_pointer __result = __end_node();
2107	__node_pointer __rt = __root();	2245	__node_pointer __rt = __root();
		2246	auto __comp = __lazy_synth_three_way_comparator<value_compare, _Key, value_type>(value_comp());
2108	while (__rt != nullptr) {	2247	while (__rt != nullptr) {
2109	if (value_comp()(__k, __rt->__value_)) {	2248	auto __comp_res = __comp(__k, __rt->__get_value());
		2249	if (__comp_res.__less()) {
2110	__result = static_cast<__end_node_pointer>(__rt);	2250	__result = static_cast<__end_node_pointer>(__rt);
2111	__rt = static_cast<__node_pointer>(__rt->__left_);	2251	__rt = static_cast<__node_pointer>(__rt->__left_);
2112	} else if (value_comp()(__rt->__value_, __k))	2252	} else if (__comp_res.__greater())
2113	__rt = static_cast<__node_pointer>(__rt->__right_);	2253	__rt = static_cast<__node_pointer>(__rt->__right_);
2114	else	2254	else
2115	return _Pp(iterator(__rt),	2255	return _Pp(iterator(__rt),
...	@@ -2124,14 +2264,16 @@ template <class _Key>	...	@@ -2124,14 +2264,16 @@ template <class _Key>
2124	pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,	2264	pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
2125	typename __tree<_Tp, _Compare, _Allocator>::const_iterator>	2265	typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
2126	__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const {	2266	__tree<_Tp, _Compare, _Allocator>::__equal_range_unique(const _Key& __k) const {
2127	typedef pair<const_iterator, const_iterator> _Pp;	2267	using _Pp = pair<const_iterator, const_iterator>;
2128	__end_node_pointer __result = __end_node();	2268	__end_node_pointer __result = __end_node();
2129	__node_pointer __rt = __root();	2269	__node_pointer __rt = __root();
		2270	auto __comp = __lazy_synth_three_way_comparator<value_compare, _Key, value_type>(value_comp());
2130	while (__rt != nullptr) {	2271	while (__rt != nullptr) {
2131	if (value_comp()(__k, __rt->__value_)) {	2272	auto __comp_res = __comp(__k, __rt->__get_value());
		2273	if (__comp_res.__less()) {
2132	__result = static_cast<__end_node_pointer>(__rt);	2274	__result = static_cast<__end_node_pointer>(__rt);
2133	__rt = static_cast<__node_pointer>(__rt->__left_);	2275	__rt = static_cast<__node_pointer>(__rt->__left_);
2134	} else if (value_comp()(__rt->__value_, __k))	2276	} else if (__comp_res.__greater())
2135	__rt = static_cast<__node_pointer>(__rt->__right_);	2277	__rt = static_cast<__node_pointer>(__rt->__right_);
2136	else	2278	else
2137	return _Pp(	2279	return _Pp(
...	@@ -2146,18 +2288,21 @@ template <class _Tp, class _Compare, class _Allocator>	...	@@ -2146,18 +2288,21 @@ template <class _Tp, class _Compare, class _Allocator>
2146	template <class _Key>	2288	template <class _Key>
2147	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, typename __tree<_Tp, _Compare, _Allocator>::iterator>	2289	pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, typename __tree<_Tp, _Compare, _Allocator>::iterator>
2148	__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) {	2290	__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) {
2149	typedef pair<iterator, iterator> _Pp;	2291	using _Pp = pair<iterator, iterator>;
2150	__end_node_pointer __result = __end_node();	2292	__end_node_pointer __result = __end_node();
2151	__node_pointer __rt = __root();	2293	__node_pointer __rt = __root();
		2294	auto __comp = __lazy_synth_three_way_comparator<value_compare, _Key, value_type>(value_comp());
2152	while (__rt != nullptr) {	2295	while (__rt != nullptr) {
2153	if (value_comp()(__k, __rt->__value_)) {	2296	auto __comp_res = __comp(__k, __rt->__get_value());
		2297	if (__comp_res.__less()) {
2154	__result = static_cast<__end_node_pointer>(__rt);	2298	__result = static_cast<__end_node_pointer>(__rt);
2155	__rt = static_cast<__node_pointer>(__rt->__left_);	2299	__rt = static_cast<__node_pointer>(__rt->__left_);
2156	} else if (value_comp()(__rt->__value_, __k))	2300	} else if (__comp_res.__greater())
2157	__rt = static_cast<__node_pointer>(__rt->__right_);	2301	__rt = static_cast<__node_pointer>(__rt->__right_);
2158	else	2302	else
2159	return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),	2303	return _Pp(
2160	__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));	2304	__lower_bound_multi(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
		2305	__upper_bound_multi(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2161	}	2306	}
2162	return _Pp(iterator(__result), iterator(__result));	2307	return _Pp(iterator(__result), iterator(__result));
2163	}	2308	}
...	@@ -2167,18 +2312,21 @@ template <class _Key>	...	@@ -2167,18 +2312,21 @@ template <class _Key>
2167	pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,	2312	pair<typename __tree<_Tp, _Compare, _Allocator>::const_iterator,
2168	typename __tree<_Tp, _Compare, _Allocator>::const_iterator>	2313	typename __tree<_Tp, _Compare, _Allocator>::const_iterator>
2169	__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const {	2314	__tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const {
2170	typedef pair<const_iterator, const_iterator> _Pp;	2315	using _Pp = pair<const_iterator, const_iterator>;
2171	__end_node_pointer __result = __end_node();	2316	__end_node_pointer __result = __end_node();
2172	__node_pointer __rt = __root();	2317	__node_pointer __rt = __root();
		2318	auto __comp = __lazy_synth_three_way_comparator<value_compare, _Key, value_type>(value_comp());
2173	while (__rt != nullptr) {	2319	while (__rt != nullptr) {
2174	if (value_comp()(__k, __rt->__value_)) {	2320	auto __comp_res = __comp(__k, __rt->__get_value());
		2321	if (__comp_res.__less()) {
2175	__result = static_cast<__end_node_pointer>(__rt);	2322	__result = static_cast<__end_node_pointer>(__rt);
2176	__rt = static_cast<__node_pointer>(__rt->__left_);	2323	__rt = static_cast<__node_pointer>(__rt->__left_);
2177	} else if (value_comp()(__rt->__value_, __k))	2324	} else if (__comp_res.__greater())
2178	__rt = static_cast<__node_pointer>(__rt->__right_);	2325	__rt = static_cast<__node_pointer>(__rt->__right_);
2179	else	2326	else
2180	return _Pp(__lower_bound(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),	2327	return _Pp(
2181	__upper_bound(__k, static_cast<__node_pointer>(__rt->__right_), __result));	2328	__lower_bound_multi(__k, static_cast<__node_pointer>(__rt->__left_), static_cast<__end_node_pointer>(__rt)),
		2329	__upper_bound_multi(__k, static_cast<__node_pointer>(__rt->__right_), __result));
2182	}	2330	}
2183	return _Pp(const_iterator(__result), const_iterator(__result));	2331	return _Pp(const_iterator(__result), const_iterator(__result));
2184	}	2332	}
...	@@ -2187,13 +2335,13 @@ template <class _Tp, class _Compare, class _Allocator>	...	@@ -2187,13 +2335,13 @@ template <class _Tp, class _Compare, class _Allocator>
2187	typename __tree<_Tp, _Compare, _Allocator>::__node_holder	2335	typename __tree<_Tp, _Compare, _Allocator>::__node_holder
2188	__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT {	2336	__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT {
2189	__node_pointer __np = __p.__get_np();	2337	__node_pointer __np = __p.__get_np();
2190	if (__begin_node() == __p.__ptr_) {	2338	if (__begin_node_ == __p.__ptr_) {
2191	if (__np->__right_ != nullptr)	2339	if (__np->__right_ != nullptr)
2192	__begin_node() = static_cast<__end_node_pointer>(__np->__right_);	2340	__begin_node_ = static_cast<__end_node_pointer>(__np->__right_);
2193	else	2341	else
2194	__begin_node() = static_cast<__end_node_pointer>(__np->__parent_);	2342	__begin_node_ = static_cast<__end_node_pointer>(__np->__parent_);
2195	}	2343	}
2196	--size();	2344	--__size_;
2197	std::__tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__np));	2345	std::__tree_remove(__end_node()->__left_, static_cast<__node_base_pointer>(__np));
2198	return __node_holder(__np, _Dp(__node_alloc(), true));	2346	return __node_holder(__np, _Dp(__node_alloc(), true));
2199	}	2347	}

lib/libcxx/include/__tuple/sfinae_helpers.h+1-44

...	@@ -10,20 +10,6 @@	...	@@ -10,20 +10,6 @@
10	#define _LIBCPP___TUPLE_SFINAE_HELPERS_H	10	#define _LIBCPP___TUPLE_SFINAE_HELPERS_H
11		11
12	#include <__config>	12	#include <__config>
13	#include <__cstddef/size_t.h>
14	#include <__fwd/tuple.h>
15	#include <__tuple/make_tuple_types.h>
16	#include <__tuple/tuple_element.h>
17	#include <__tuple/tuple_like_ext.h>
18	#include <__tuple/tuple_size.h>
19	#include <__tuple/tuple_types.h>
20	#include <__type_traits/conjunction.h>
21	#include <__type_traits/enable_if.h>
22	#include <__type_traits/integral_constant.h>
23	#include <__type_traits/is_constructible.h>
24	#include <__type_traits/is_same.h>
25	#include <__type_traits/remove_cvref.h>
26	#include <__type_traits/remove_reference.h>
27		13
28	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	14	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
29	# pragma GCC system_header	15	# pragma GCC system_header
...	@@ -33,36 +19,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -33,36 +19,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
33		19
34	#ifndef _LIBCPP_CXX03_LANG	20	#ifndef _LIBCPP_CXX03_LANG
35		21
36	struct __tuple_sfinae_base {	22	struct __check_tuple_constructor_fail {
37	template <template <class, class...> class _Trait, class... _LArgs, class... _RArgs>
38	static auto __do_test(__tuple_types<_LArgs...>,
39	__tuple_types<_RArgs...>) -> __all<__enable_if_t<_Trait<_LArgs, _RArgs>::value, bool>{true}...>;
40	template <template <class...> class>
41	static auto __do_test(...) -> false_type;
42
43	template <class _FromArgs, class _ToArgs>
44	using __constructible _LIBCPP_NODEBUG = decltype(__do_test<is_constructible>(_ToArgs{}, _FromArgs{}));
45	};
46
47	// __tuple_constructible
48
49	template <class _Tp,
50	class _Up,
51	bool = __tuple_like_ext<__libcpp_remove_reference_t<_Tp> >::value,
52	bool = __tuple_like_ext<_Up>::value>
53	struct __tuple_constructible : public false_type {};
54
55	template <class _Tp, class _Up>
56	struct __tuple_constructible<_Tp, _Up, true, true>
57	: public __tuple_sfinae_base::__constructible< typename __make_tuple_types<_Tp>::type,
58	typename __make_tuple_types<_Up>::type > {};
59
60	template <size_t _Ip, class... _Tp>
61	struct tuple_element<_Ip, tuple<_Tp...> > {
62	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, __tuple_types<_Tp...> >::type;
63	};
64
65	struct _LIBCPP_EXPORTED_FROM_ABI __check_tuple_constructor_fail {
66	static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }	23	static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_explicit_default() { return false; }
67	static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }	24	static _LIBCPP_HIDE_FROM_ABI constexpr bool __enable_implicit_default() { return false; }
68	template <class...>	25	template <class...>

lib/libcxx/include/__tuple/tuple_element.h-12

 @@ -11,8 +11,6 @@
 #include <__config>
 #include <__cstddef/size_t.h>
-#include <__tuple/tuple_indices.h>
-#include <__tuple/tuple_types.h>
 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
 #  pragma GCC system_header
 @@ -38,21 +36,11 @@ struct tuple_element<_Ip, const volatile _Tp> {
   using type _LIBCPP_NODEBUG = const volatile typename tuple_element<_Ip, _Tp>::type;
 };
-#ifndef _LIBCPP_CXX03_LANG
-template <size_t _Ip, class... _Types>
-struct tuple_element<_Ip, __tuple_types<_Types...> > {
-  static_assert(_Ip < sizeof...(_Types), "tuple_element index out of range");
-  using type _LIBCPP_NODEBUG = __type_pack_element<_Ip, _Types...>;
-};
 #  if _LIBCPP_STD_VER >= 14
 template <size_t _Ip, class... _Tp>
 using tuple_element_t _LIBCPP_NODEBUG = typename tuple_element<_Ip, _Tp...>::type;
 #  endif
-#endif // _LIBCPP_CXX03_LANG
 _LIBCPP_END_NAMESPACE_STD
 #endif // _LIBCPP___TUPLE_TUPLE_ELEMENT_H

lib/libcxx/include/__tuple/tuple_size.h-4

...	@@ -12,7 +12,6 @@	...	@@ -12,7 +12,6 @@
12	#include <__config>	12	#include <__config>
13	#include <__cstddef/size_t.h>	13	#include <__cstddef/size_t.h>
14	#include <__fwd/tuple.h>	14	#include <__fwd/tuple.h>
15	#include <__tuple/tuple_types.h>
16	#include <__type_traits/enable_if.h>	15	#include <__type_traits/enable_if.h>
17	#include <__type_traits/integral_constant.h>	16	#include <__type_traits/integral_constant.h>
18	#include <__type_traits/is_const.h>	17	#include <__type_traits/is_const.h>
...	@@ -59,9 +58,6 @@ struct tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};	...	@@ -59,9 +58,6 @@ struct tuple_size<const volatile _Tp> : public tuple_size<_Tp> {};
59	template <class... _Tp>	58	template <class... _Tp>
60	struct tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};	59	struct tuple_size<tuple<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
61		60
62	template <class... _Tp>
63	struct tuple_size<__tuple_types<_Tp...> > : public integral_constant<size_t, sizeof...(_Tp)> {};
64
65	# if _LIBCPP_STD_VER >= 17	61	# if _LIBCPP_STD_VER >= 17
66	template <class _Tp>	62	template <class _Tp>
67	inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;	63	inline constexpr size_t tuple_size_v = tuple_size<_Tp>::value;

lib/libcxx/include/__tuple/tuple_transform.h created+45

...	@@ -0,0 +1,45 @@
1	// -- C++ --
2	//===----------------------------------------------------------------------===//
3	//
4	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5	// See https://llvm.org/LICENSE.txt for license information.
6	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7	//
8	//===----------------------------------------------------------------------===//
9
10	#ifndef _LIBCPP___TUPLE_TUPLE_TRANSFORM_H
11	#define _LIBCPP___TUPLE_TUPLE_TRANSFORM_H
12
13	#include <__config>
14
15	#include <__functional/invoke.h>
16	#include <__utility/forward.h>
17	#include <tuple>
18
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header
21	#endif
22
23	_LIBCPP_PUSH_MACROS
24	#include <__undef_macros>
25
26	_LIBCPP_BEGIN_NAMESPACE_STD
27
28	#if _LIBCPP_STD_VER >= 23
29
30	template <class _Fun, class _Tuple>
31	_LIBCPP_HIDE_FROM_ABI constexpr auto __tuple_transform(_Fun&& __f, _Tuple&& __tuple) {
32	return std::apply(
33	[&]<class... _Types>(_Types&&... __elements) {
34	return tuple<invoke_result_t<_Fun&, _Types>...>(std::invoke(__f, std::forward<_Types>(__elements))...);
35	},
36	std::forward<_Tuple>(__tuple));
37	}
38
39	#endif // _LIBCPP_STD_VER >= 23
40
41	_LIBCPP_END_NAMESPACE_STD
42
43	_LIBCPP_POP_MACROS
44
45	#endif // _LIBCPP___TUPLE_TUPLE_TRANSFORM_H

lib/libcxx/include/__type_traits/aligned_storage.h+13-40

...	@@ -11,8 +11,6 @@	...	@@ -11,8 +11,6 @@
11		11
12	#include <__config>	12	#include <__config>
13	#include <__cstddef/size_t.h>	13	#include <__cstddef/size_t.h>
14	#include <__type_traits/integral_constant.h>
15	#include <__type_traits/type_list.h>
16		14
17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	15	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
18	# pragma GCC system_header	16	# pragma GCC system_header
...	@@ -21,10 +19,10 @@	...	@@ -21,10 +19,10 @@
21	_LIBCPP_BEGIN_NAMESPACE_STD	19	_LIBCPP_BEGIN_NAMESPACE_STD
22		20
23	template <class _Tp>	21	template <class _Tp>
24	struct __align_type {	22	struct _ALIGNAS(_LIBCPP_PREFERRED_ALIGNOF(_Tp)) _AlignedAsT {};
25	static const size_t value = _LIBCPP_PREFERRED_ALIGNOF(_Tp);	23
26	typedef _Tp type;	24	template <class... _Args>
27	};	25	struct __max_align_impl : _AlignedAsT<_Args>... {};
28		26
29	struct __struct_double {	27	struct __struct_double {
30	long double __lx;	28	long double __lx;
...	@@ -33,41 +31,16 @@ struct __struct_double4 {	...	@@ -33,41 +31,16 @@ struct __struct_double4 {
33	double __lx[4];	31	double __lx[4];
34	};	32	};
35		33
36	using __all_types _LIBCPP_NODEBUG =	34	inline const size_t __aligned_storage_max_align =
37	__type_list<__align_type<unsigned char>,	35	_LIBCPP_ALIGNOF(__max_align_impl<unsigned long long, double, long double, __struct_double, __struct_double4, int*>);
38	__align_type<unsigned short>,
39	__align_type<unsigned int>,
40	__align_type<unsigned long>,
41	__align_type<unsigned long long>,
42	__align_type<double>,
43	__align_type<long double>,
44	__align_type<__struct_double>,
45	__align_type<__struct_double4>,
46	__align_type<int*> >;
47
48	template <class _TL, size_t _Len>
49	struct __find_max_align;
50
51	template <class _Head, size_t _Len>
52	struct __find_max_align<__type_list<_Head>, _Len> : public integral_constant<size_t, _Head::value> {};
53
54	template <size_t _Len, size_t _A1, size_t _A2>
55	struct __select_align {
56	private:
57	static const size_t __min = _A2 < _A1 ? _A2 : _A1;
58	static const size_t __max = _A1 < _A2 ? _A2 : _A1;
59
60	public:
61	static const size_t value = _Len < __max ? __min : __max;
62	};
63		36
64	template <class _Head, class... _Tail, size_t _Len>	37	template <size_t _Len>
65	struct __find_max_align<__type_list<_Head, _Tail...>, _Len>	38	inline const size_t __aligned_storage_alignment =
66	: public integral_constant<	39	_Len > __aligned_storage_max_align
67	size_t,	40	? __aligned_storage_max_align
68	__select_align<_Len, _Head::value, __find_max_align<__type_list<_Tail...>, _Len>::value>::value> {};	41	: size_t(1) << ((sizeof(size_t) * __CHAR_BIT__) - __builtin_clzg(_Len) - 1);
69		42
70	template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>	43	template <size_t _Len, size_t _Align = __aligned_storage_alignment<_Len> >
71	struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_NO_SPECIALIZATIONS aligned_storage {	44	struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_NO_SPECIALIZATIONS aligned_storage {
72	union _ALIGNAS(_Align) type {	45	union _ALIGNAS(_Align) type {
73	unsigned char __data[(_Len + _Align - 1) / _Align * _Align];	46	unsigned char __data[(_Len + _Align - 1) / _Align * _Align];
...	@@ -77,7 +50,7 @@ struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_NO_SPECIALIZATIONS aligned_storage {	...	@@ -77,7 +50,7 @@ struct _LIBCPP_DEPRECATED_IN_CXX23 _LIBCPP_NO_SPECIALIZATIONS aligned_storage {
77	#if _LIBCPP_STD_VER >= 14	50	#if _LIBCPP_STD_VER >= 14
78		51
79	_LIBCPP_SUPPRESS_DEPRECATED_PUSH	52	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
80	template <size_t _Len, size_t _Align = __find_max_align<__all_types, _Len>::value>	53	template <size_t _Len, size_t _Align = __aligned_storage_alignment<_Len> >
81	using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;	54	using aligned_storage_t _LIBCPP_DEPRECATED_IN_CXX23 = typename aligned_storage<_Len, _Align>::type;
82	_LIBCPP_SUPPRESS_DEPRECATED_POP	55	_LIBCPP_SUPPRESS_DEPRECATED_POP
83		56

lib/libcxx/include/__type_traits/desugars_to.h+4

...	@@ -10,6 +10,7 @@	...	@@ -10,6 +10,7 @@
10	#define _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H	10	#define _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H
11		11
12	#include <__config>	12	#include <__config>
		13	#include <__type_traits/integral_constant.h>
13		14
14	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	15	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15	# pragma GCC system_header	16	# pragma GCC system_header
...	@@ -64,6 +65,9 @@ template <class _CanonicalTag, class _Operation, class... _Args>	...	@@ -64,6 +65,9 @@ template <class _CanonicalTag, class _Operation, class... _Args>
64	inline const bool __desugars_to_v<_CanonicalTag, _Operation&&, _Args...> =	65	inline const bool __desugars_to_v<_CanonicalTag, _Operation&&, _Args...> =
65	__desugars_to_v<_CanonicalTag, _Operation, _Args...>;	66	__desugars_to_v<_CanonicalTag, _Operation, _Args...>;
66		67
		68	template <class _CanonicalTag, class _Operation, class... _Args>
		69	struct __desugars_to : integral_constant<bool, __desugars_to_v<_CanonicalTag, _Operation, _Args...> > {};
		70
67	_LIBCPP_END_NAMESPACE_STD	71	_LIBCPP_END_NAMESPACE_STD
68		72
69	#endif // _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H	73	#endif // _LIBCPP___TYPE_TRAITS_DESUGARS_TO_H

lib/libcxx/include/__type_traits/invoke.h+8

 @@ -62,6 +62,9 @@
 //
 // template <class Func, class... Args>
 // using __invoke_result_t = invoke_result_t<Func, Args...>;
+//
+// template <class Ret, class Func, class... Args>
+// struct __is_invocable_r : is_invocable_r<Ret, Func, Args...> {};
 _LIBCPP_BEGIN_NAMESPACE_STD
 @@ -112,8 +115,10 @@ inline const bool __is_invocable_r_v = __is_invocable_r_impl<_Ret, __is_invocabl
 template <bool __is_invocable, class... _Args>
 inline const bool __is_nothrow_invocable_impl = false;
+#  ifndef _LIBCPP_CXX03_LANG
 template <class... _Args>
 inline const bool __is_nothrow_invocable_impl<true, _Args...> = noexcept(__builtin_invoke(std::declval<_Args>()...));
+#  endif
 template <class... _Args>
 inline const bool __is_nothrow_invocable_v = __is_nothrow_invocable_impl<__is_invocable_v<_Args...>, _Args...>;
 @@ -327,6 +332,9 @@ using __invoke_result_t _LIBCPP_NODEBUG = typename __invoke_result<_Func, _Args.
 #endif // __has_builtin(__builtin_invoke_r)
+template <class _Ret, class _Func, class... _Args>
+struct __is_invocable_r : integral_constant<bool, __is_invocable_r_v<_Ret, _Func, _Args...> > {};
 template <class _Ret, bool = is_void<_Ret>::value>
 struct __invoke_void_return_wrapper {
   template <class... _Args>

lib/libcxx/include/__type_traits/is_allocator.h+6-7

 @@ -11,7 +11,6 @@
 #include <__config>
 #include <__cstddef/size_t.h>
-#include <__type_traits/integral_constant.h>
 #include <__type_traits/void_t.h>
 #include <__utility/declval.h>
 @@ -21,13 +20,13 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <typename _Alloc, typename = void, typename = void>
+template <class _Alloc, class = void, class = void>
-struct __is_allocator : false_type {};
+inline const bool __is_allocator_v = false;
-template <typename _Alloc>
+template <class _Alloc>
-struct __is_allocator<_Alloc,
+inline const bool __is_allocator_v<_Alloc,
-                      __void_t<typename _Alloc::value_type>,
+                                   __void_t<typename _Alloc::value_type>,
-                      __void_t<decltype(std::declval<_Alloc&>().allocate(size_t(0)))> > : true_type {};
+                                   __void_t<decltype(std::declval<_Alloc&>().allocate(size_t()))> > = true;
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__type_traits/is_array.h+26

...	@@ -26,6 +26,32 @@ template <class _Tp>	...	@@ -26,6 +26,32 @@ template <class _Tp>
26	_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_array_v = __is_array(_Tp);	26	_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_array_v = __is_array(_Tp);
27	#endif	27	#endif
28		28
		29	template <class _Tp>
		30	inline const bool __is_bounded_array_v = __is_bounded_array(_Tp);
		31
		32	#if _LIBCPP_STD_VER >= 20
		33
		34	template <class _Tp>
		35	struct _LIBCPP_NO_SPECIALIZATIONS is_bounded_array : bool_constant<__is_bounded_array(_Tp)> {};
		36
		37	template <class _Tp>
		38	_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_bounded_array_v = __is_bounded_array(_Tp);
		39
		40	#endif
		41
		42	template <class _Tp>
		43	inline const bool __is_unbounded_array_v = __is_unbounded_array(_Tp);
		44
		45	#if _LIBCPP_STD_VER >= 20
		46
		47	template <class _Tp>
		48	struct _LIBCPP_NO_SPECIALIZATIONS is_unbounded_array : bool_constant<__is_unbounded_array(_Tp)> {};
		49
		50	template <class _Tp>
		51	_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_unbounded_array_v = __is_unbounded_array(_Tp);
		52
		53	#endif
		54
29	_LIBCPP_END_NAMESPACE_STD	55	_LIBCPP_END_NAMESPACE_STD
30		56
31	#endif // _LIBCPP___TYPE_TRAITS_IS_ARRAY_H	57	#endif // _LIBCPP___TYPE_TRAITS_IS_ARRAY_H

lib/libcxx/include/__type_traits/is_equality_comparable.h+16-21

 @@ -27,11 +27,11 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _Tp, class _Up, class = void>
-struct __is_equality_comparable : false_type {};
+inline const bool __is_equality_comparable_v = false;
 template <class _Tp, class _Up>
-struct __is_equality_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() == std::declval<_Up>())> > : true_type {
+inline const bool
-};
+    __is_equality_comparable_v<_Tp, _Up, __void_t<decltype(std::declval<_Tp>() == std::declval<_Up>())> > = true;
 // A type is_trivially_equality_comparable if the expression `a == b` is equivalent to `std::memcmp(&a, &b, sizeof(T))`
 // (with `a` and `b` being of type `T`). For the case where we compare two object of the same type, we can use
 @@ -48,40 +48,35 @@ struct __is_equality_comparable<_Tp, _Up, __void_t<decltype(std::declval<_Tp>()
 //   representation may not be equivalent.
 template <class _Tp, class _Up, class = void>
-struct __libcpp_is_trivially_equality_comparable_impl : false_type {};
+inline const bool __is_trivially_equality_comparable_impl = false;
 template <class _Tp>
-struct __libcpp_is_trivially_equality_comparable_impl<_Tp, _Tp>
+inline const bool __is_trivially_equality_comparable_impl<_Tp, _Tp>
 #if __has_builtin(__is_trivially_equality_comparable)
-    : integral_constant<bool, __is_trivially_equality_comparable(_Tp) && __is_equality_comparable<_Tp, _Tp>::value> {
+    = __is_trivially_equality_comparable(_Tp) && __is_equality_comparable_v<_Tp, _Tp>;
-};
 #else
-    : is_integral<_Tp> {
+    = is_integral<_Tp>::value;
-};
 #endif // __has_builtin(__is_trivially_equality_comparable)
 template <class _Tp, class _Up>
-struct __libcpp_is_trivially_equality_comparable_impl<
+inline const bool __is_trivially_equality_comparable_impl<
     _Tp,
     _Up,
-    __enable_if_t<is_integral<_Tp>::value && is_integral<_Up>::value && !is_same<_Tp, _Up>::value &&
+    __enable_if_t<is_integral<_Tp>::value && is_integral<_Up>::value && !is_same<_Tp, _Up>::value> > =
-                  is_signed<_Tp>::value == is_signed<_Up>::value && sizeof(_Tp) == sizeof(_Up)> > : true_type {};
+    is_signed<_Tp>::value == is_signed<_Up>::value && sizeof(_Tp) == sizeof(_Up);
 template <class _Tp>
-struct __libcpp_is_trivially_equality_comparable_impl<_Tp*, _Tp*> : true_type {};
+inline const bool __is_trivially_equality_comparable_impl<_Tp*, _Tp*> = true;
 // TODO: Use is_pointer_inverconvertible_base_of
 template <class _Tp, class _Up>
-struct __libcpp_is_trivially_equality_comparable_impl<_Tp*, _Up*>
+inline const bool __is_trivially_equality_comparable_impl<_Tp*, _Up*> =
-    : integral_constant<
+    __is_equality_comparable_v<_Tp*, _Up*> &&
-          bool,
+    (is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value || is_void<_Tp>::value || is_void<_Up>::value);
-          __is_equality_comparable<_Tp*, _Up*>::value &&
-              (is_same<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >::value || is_void<_Tp>::value || is_void<_Up>::value)> {
-};
 template <class _Tp, class _Up>
-using __libcpp_is_trivially_equality_comparable _LIBCPP_NODEBUG =
+inline const bool __is_trivially_equality_comparable_v =
-    __libcpp_is_trivially_equality_comparable_impl<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >;
+    __is_trivially_equality_comparable_impl<__remove_cv_t<_Tp>, __remove_cv_t<_Up> >;
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__type_traits/is_final.h+1-1

...	@@ -19,7 +19,7 @@	...	@@ -19,7 +19,7 @@
19	_LIBCPP_BEGIN_NAMESPACE_STD	19	_LIBCPP_BEGIN_NAMESPACE_STD
20		20
21	template <class _Tp>	21	template <class _Tp>
22	struct __libcpp_is_final : integral_constant<bool, __is_final(_Tp)> {};	22	inline const bool __is_final_v = __is_final(_Tp);
23		23
24	#if _LIBCPP_STD_VER >= 14	24	#if _LIBCPP_STD_VER >= 14
25	template <class _Tp>	25	template <class _Tp>

lib/libcxx/include/__type_traits/is_floating_point.h+7-6

 @@ -20,18 +20,19 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 // clang-format off
-template <class _Tp> struct __libcpp_is_floating_point              : false_type {};
+template <class _Tp> inline const bool __is_floating_point_impl              = false;
-template <>          struct __libcpp_is_floating_point<float>       : true_type {};
+template <>          inline const bool __is_floating_point_impl<float>       = true;
-template <>          struct __libcpp_is_floating_point<double>      : true_type {};
+template <>          inline const bool __is_floating_point_impl<double>      = true;
-template <>          struct __libcpp_is_floating_point<long double> : true_type {};
+template <>          inline const bool __is_floating_point_impl<long double> = true;
 // clang-format on
 template <class _Tp>
-struct _LIBCPP_NO_SPECIALIZATIONS is_floating_point : __libcpp_is_floating_point<__remove_cv_t<_Tp> > {};
+struct _LIBCPP_NO_SPECIALIZATIONS is_floating_point
+    : integral_constant<bool, __is_floating_point_impl<__remove_cv_t<_Tp> > > {};
 #if _LIBCPP_STD_VER >= 17
 template <class _Tp>
-_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_floating_point_v = is_floating_point<_Tp>::value;
+_LIBCPP_NO_SPECIALIZATIONS inline constexpr bool is_floating_point_v = __is_floating_point_impl<__remove_cv_t<_Tp>>;
 #endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__type_traits/is_generic_transparent_comparator.h created+30

...	@@ -0,0 +1,30 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___TYPE_TRAITS_IS_GENERIC_TRANSPARENT_COMPARATOR_H
10	#define _LIBCPP___TYPE_TRAITS_IS_GENERIC_TRANSPARENT_COMPARATOR_H
11
12	#include <__config>
13
14	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15	# pragma GCC system_header
16	#endif
17
18	_LIBCPP_BEGIN_NAMESPACE_STD
19
20	// This trait returns true if the given _Comparator is known to accept any two types for comparison. This is separate
21	// from `__is_transparent_v`, since that only enables overloads of specific functions, but doesn't give any semantic
22	// guarantees. This trait guarantess that the comparator simply calls the appropriate comparison functions for any two
23	// types.
24
25	template <class _Comparator>
26	inline const bool __is_generic_transparent_comparator_v = false;
27
28	_LIBCPP_END_NAMESPACE_STD
29
30	#endif // _LIBCPP___TYPE_TRAITS_IS_GENERIC_TRANSPARENT_COMPARATOR_H

lib/libcxx/include/__type_traits/is_specialization.h+2-6

 @@ -30,15 +30,11 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER >= 17
 template <class _Tp, template <class...> class _Template>
-inline constexpr bool __is_specialization_v = false; // true if and only if _Tp is a specialization of _Template
+inline const bool __is_specialization_v = false; // true if and only if _Tp is a specialization of _Template
 template <template <class...> class _Template, class... _Args>
-inline constexpr bool __is_specialization_v<_Template<_Args...>, _Template> = true;
+inline const bool __is_specialization_v<_Template<_Args...>, _Template> = true;
-#endif // _LIBCPP_STD_VER >= 17
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__type_traits/is_within_lifetime.h created+29

...	@@ -0,0 +1,29 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___TYPE_TRAITS_IS_WITHIN_LIFETIME_H
10	#define _LIBCPP___TYPE_TRAITS_IS_WITHIN_LIFETIME_H
11
12	#include <__config>
13
14	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
15	# pragma GCC system_header
16	#endif
17
18	_LIBCPP_BEGIN_NAMESPACE_STD
19
20	#if _LIBCPP_STD_VER >= 26 && __has_builtin(__builtin_is_within_lifetime)
21	template <class _Tp>
22	_LIBCPP_HIDE_FROM_ABI consteval bool is_within_lifetime(const _Tp* __p) noexcept {
23	return __builtin_is_within_lifetime(__p);
24	}
25	#endif
26
27	_LIBCPP_END_NAMESPACE_STD
28
29	#endif // _LIBCPP___TYPE_TRAITS_IS_WITHIN_LIFETIME_H

lib/libcxx/include/__type_traits/make_transparent.h created+52

...	@@ -0,0 +1,52 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___TYPE_TRAITS_MAKE_TRANSPARENT_H
10	#define _LIBCPP___TYPE_TRAITS_MAKE_TRANSPARENT_H
11
12	#include <__config>
13	#include <__type_traits/enable_if.h>
14	#include <__type_traits/is_empty.h>
15	#include <__type_traits/is_same.h>
16
17	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
18	# pragma GCC system_header
19	#endif
20
21	_LIBCPP_BEGIN_NAMESPACE_STD
22
23	// __make_transparent tries to create a transparent comparator from its non-transparent counterpart, e.g. obtain
24	// `less<>` from `less<T>`. This is useful in cases where conversions can be avoided (e.g. a string literal to a
25	// std::string).
26
27	template <class _Tp, class _Comparator>
28	struct __make_transparent {
29	using type _LIBCPP_NODEBUG = _Comparator;
30	};
31
32	template <class _Tp, class _Comparator>
33	using __make_transparent_t _LIBCPP_NODEBUG = typename __make_transparent<_Tp, _Comparator>::type;
34
35	template <class _Tp,
36	class _Comparator,
37	__enable_if_t<is_same<_Comparator, __make_transparent_t<_Tp, _Comparator> >::value, int> = 0>
38	_LIBCPP_HIDE_FROM_ABI _Comparator& __as_transparent(_Comparator& __comp) {
39	return __comp;
40	}
41
42	template <class _Tp,
43	class _Comparator,
44	__enable_if_t<!is_same<_Comparator, __make_transparent_t<_Tp, _Comparator> >::value, int> = 0>
45	_LIBCPP_HIDE_FROM_ABI __make_transparent_t<_Tp, _Comparator> __as_transparent(_Comparator&) {
46	static_assert(is_empty<_Comparator>::value);
47	return __make_transparent_t<_Tp, _Comparator>();
48	}
49
50	_LIBCPP_END_NAMESPACE_STD
51
52	#endif // _LIBCPP___TYPE_TRAITS_MAKE_TRANSPARENT_H

lib/libcxx/include/__type_traits/reference_constructs_from_temporary.h+1-7

 @@ -18,7 +18,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-#if _LIBCPP_STD_VER >= 23 && __has_builtin(__reference_constructs_from_temporary)
+#if _LIBCPP_STD_VER >= 23
 template <class _Tp, class _Up>
 struct _LIBCPP_NO_SPECIALIZATIONS reference_constructs_from_temporary
 @@ -30,14 +30,8 @@ _LIBCPP_NO_SPECIALIZATIONS inline constexpr bool reference_constructs_from_tempo
 #endif
-#if __has_builtin(__reference_constructs_from_temporary)
 template <class _Tp, class _Up>
 inline const bool __reference_constructs_from_temporary_v = __reference_constructs_from_temporary(_Tp, _Up);
-#else
-// TODO(LLVM 22): Remove this as all supported compilers should have __reference_constructs_from_temporary implemented.
-template <class _Tp, class _Up>
-inline const bool __reference_constructs_from_temporary_v = __reference_binds_to_temporary(_Tp, _Up);
-#endif
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/__type_traits/reference_converts_from_temporary.h+1-1

...	@@ -18,7 +18,7 @@	...	@@ -18,7 +18,7 @@
18		18
19	_LIBCPP_BEGIN_NAMESPACE_STD	19	_LIBCPP_BEGIN_NAMESPACE_STD
20		20
21	#if _LIBCPP_STD_VER >= 23 && __has_builtin(__reference_converts_from_temporary)	21	#if _LIBCPP_STD_VER >= 23
22		22
23	template <class _Tp, class _Up>	23	template <class _Tp, class _Up>
24	struct _LIBCPP_NO_SPECIALIZATIONS reference_converts_from_temporary	24	struct _LIBCPP_NO_SPECIALIZATIONS reference_converts_from_temporary

lib/libcxx/include/__utility/cmp.h+19-7

 @@ -26,10 +26,18 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 #if _LIBCPP_STD_VER >= 20
+template <typename _Tp, typename _Ip>
+concept __comparison_can_promote_to =
+    sizeof(_Tp) < sizeof(_Ip) || (sizeof(_Tp) == sizeof(_Ip) && __signed_integer<_Tp>);
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept {
   if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
     return __t == __u;
+  else if constexpr (__comparison_can_promote_to<_Tp, int> && __comparison_can_promote_to<_Up, int>)
+    return static_cast<int>(__t) == static_cast<int>(__u);
+  else if constexpr (__comparison_can_promote_to<_Tp, long long> && __comparison_can_promote_to<_Up, long long>)
+    return static_cast<long long>(__t) == static_cast<long long>(__u);
   else if constexpr (is_signed_v<_Tp>)
     return __t < 0 ? false : make_unsigned_t<_Tp>(__t) == __u;
   else
 @@ -37,14 +45,18 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_equal(_Tp __t, _Up __u) noexcept {
 }
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_not_equal(_Tp __t, _Up __u) noexcept {
   return !std::cmp_equal(__t, __u);
 }
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept {
   if constexpr (is_signed_v<_Tp> == is_signed_v<_Up>)
     return __t < __u;
+  else if constexpr (__comparison_can_promote_to<_Tp, int> && __comparison_can_promote_to<_Up, int>)
+    return static_cast<int>(__t) < static_cast<int>(__u);
+  else if constexpr (__comparison_can_promote_to<_Tp, long long> && __comparison_can_promote_to<_Up, long long>)
+    return static_cast<long long>(__t) < static_cast<long long>(__u);
   else if constexpr (is_signed_v<_Tp>)
     return __t < 0 ? true : make_unsigned_t<_Tp>(__t) < __u;
   else
 @@ -52,22 +64,22 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less(_Tp __t, _Up __u) noexcept {
 }
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater(_Tp __t, _Up __u) noexcept {
   return std::cmp_less(__u, __t);
 }
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_less_equal(_Tp __t, _Up __u) noexcept {
   return !std::cmp_greater(__t, __u);
 }
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool cmp_greater_equal(_Tp __t, _Up __u) noexcept {
   return !std::cmp_less(__t, __u);
 }
 template <__signed_or_unsigned_integer _Tp, __signed_or_unsigned_integer _Up>
-_LIBCPP_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool in_range(_Up __u) noexcept {
   return std::cmp_less_equal(__u, numeric_limits<_Tp>::max()) &&
          std::cmp_greater_equal(__u, numeric_limits<_Tp>::min());
 }

lib/libcxx/include/__utility/default_three_way_comparator.h created+70

...	@@ -0,0 +1,70 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___UTILITY_DEFAULT_THREE_WAY_COMPARATOR_H
10	#define _LIBCPP___UTILITY_DEFAULT_THREE_WAY_COMPARATOR_H
11
12	#include <__config>
13	#include <__type_traits/enable_if.h>
14	#include <__type_traits/is_arithmetic.h>
15
16	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
17	# pragma GCC system_header
18	#endif
19
20	_LIBCPP_BEGIN_NAMESPACE_STD
21
22	// This struct can be specialized to provide a three way comparator between _LHS and _RHS.
23	// The return value should be
24	// - less than zero if (lhs_val < rhs_val)
25	// - greater than zero if (rhs_val < lhs_val)
26	// - zero otherwise
27	template <class _LHS, class _RHS, class = void>
28	struct __default_three_way_comparator;
29
30	template <class _LHS, class _RHS>
31	struct __default_three_way_comparator<_LHS,
32	_RHS,
33	__enable_if_t<is_arithmetic<_LHS>::value && is_arithmetic<_RHS>::value> > {
34	_LIBCPP_HIDE_FROM_ABI static int operator()(_LHS __lhs, _RHS __rhs) {
35	if (__lhs < __rhs)
36	return -1;
37	if (__lhs > __rhs)
38	return 1;
39	return 0;
40	}
41	};
42
43	#if _LIBCPP_STD_VER >= 20 && __has_builtin(__builtin_lt_synthesizes_from_spaceship)
44	template <class _LHS, class _RHS>
45	struct __default_three_way_comparator<
46	_LHS,
47	_RHS,
48	__enable_if_t<!(is_arithmetic<_LHS>::value && is_arithmetic<_RHS>::value) &&
49	__builtin_lt_synthesizes_from_spaceship(const _LHS&, const _RHS&)>> {
50	_LIBCPP_HIDE_FROM_ABI static int operator()(const _LHS& __lhs, const _RHS& __rhs) {
51	auto __res = __lhs <=> __rhs;
52	if (__res < 0)
53	return -1;
54	if (__res > 0)
55	return 1;
56	return 0;
57	}
58	};
59	#endif
60
61	template <class _LHS, class _RHS, bool = true>
62	struct __has_default_three_way_comparator : false_type {};
63
64	template <class _LHS, class _RHS>
65	struct __has_default_three_way_comparator<_LHS, _RHS, sizeof(__default_three_way_comparator<_LHS, _RHS>) >= 0>
66	: true_type {};
67
68	_LIBCPP_END_NAMESPACE_STD
69
70	#endif // _LIBCPP___UTILITY_DEFAULT_THREE_WAY_COMPARATOR_H

lib/libcxx/include/__utility/in_place.h+1-1

...	@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -22,7 +22,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
22		22
23	#if _LIBCPP_STD_VER >= 17	23	#if _LIBCPP_STD_VER >= 17
24		24
25	struct _LIBCPP_EXPORTED_FROM_ABI in_place_t {	25	struct in_place_t {
26	explicit in_place_t() = default;	26	explicit in_place_t() = default;
27	};	27	};
28	inline constexpr in_place_t in_place{};	28	inline constexpr in_place_t in_place{};

lib/libcxx/include/__utility/integer_sequence.h+56-41

...	@@ -11,63 +11,52 @@	...	@@ -11,63 +11,52 @@
11		11
12	#include <__config>	12	#include <__config>
13	#include <__cstddef/size_t.h>	13	#include <__cstddef/size_t.h>
		14	#include <__tuple/tuple_element.h>
		15	#include <__tuple/tuple_size.h>
14	#include <__type_traits/is_integral.h>	16	#include <__type_traits/is_integral.h>
15		17
16	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	18	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
17	# pragma GCC system_header	19	# pragma GCC system_header
18	#endif	20	#endif
19		21
		22	#ifndef _LIBCPP_CXX03_LANG
		23
20	_LIBCPP_BEGIN_NAMESPACE_STD	24	_LIBCPP_BEGIN_NAMESPACE_STD
21		25
22	template <size_t...>	26	# if __has_builtin(__make_integer_seq)
23	struct __tuple_indices;	27	template <template <class _Tp, _Tp...> class _BaseType, class _Tp, _Tp _SequenceSize>
		28	using __make_integer_sequence_impl _LIBCPP_NODEBUG = __make_integer_seq<_BaseType, _Tp, _SequenceSize>;
		29	# else
		30	template <template <class _Tp, _Tp...> class _BaseType, class _Tp, _Tp _SequenceSize>
		31	using __make_integer_sequence_impl _LIBCPP_NODEBUG = _BaseType<_Tp, __integer_pack(_SequenceSize)...>;
		32	# endif
24		33
25	template <class _IdxType, _IdxType... _Values>	34	template <class _Tp, _Tp... _Indices>
26	struct __integer_sequence {	35	struct __integer_sequence {
27	template <template <class _OIdxType, _OIdxType...> class _ToIndexSeq, class _ToIndexType>	36	using value_type = _Tp;
28	using __convert _LIBCPP_NODEBUG = _ToIndexSeq<_ToIndexType, _Values...>;	37	static_assert(is_integral<_Tp>::value, "std::integer_sequence can only be instantiated with an integral type");
29		38	[[__nodiscard__]] static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return sizeof...(_Indices); }
30	template <size_t _Sp>
31	using __to_tuple_indices _LIBCPP_NODEBUG = __tuple_indices<(_Values + _Sp)...>;
32	};	39	};
33		40
34	#if __has_builtin(__make_integer_seq)	41	template <size_t... _Indices>
35	template <size_t _Ep, size_t _Sp>	42	using __index_sequence _LIBCPP_NODEBUG = __integer_sequence<size_t, _Indices...>;
36	using __make_indices_imp _LIBCPP_NODEBUG =
37	typename __make_integer_seq<__integer_sequence, size_t, _Ep - _Sp>::template __to_tuple_indices<_Sp>;
38	#elif __has_builtin(__integer_pack)
39	template <size_t _Ep, size_t _Sp>
40	using __make_indices_imp _LIBCPP_NODEBUG =
41	typename __integer_sequence<size_t, __integer_pack(_Ep - _Sp)...>::template __to_tuple_indices<_Sp>;
42	#else
43	# error "No known way to get an integer pack from the compiler"
44	#endif
45		43
46	#if _LIBCPP_STD_VER >= 14	44	template <size_t _SequenceSize>
		45	using __make_index_sequence _LIBCPP_NODEBUG = __make_integer_sequence_impl<__integer_sequence, size_t, _SequenceSize>;
47		46
48	template <class _Tp, _Tp... _Ip>	47	template <class... _Args>
49	struct integer_sequence {	48	using __index_sequence_for _LIBCPP_NODEBUG = __make_index_sequence<sizeof...(_Args)>;
50	typedef _Tp value_type;	49
51	static_assert(is_integral<_Tp>::value, "std::integer_sequence can only be instantiated with an integral type");	50	# if _LIBCPP_STD_VER >= 14
52	static _LIBCPP_HIDE_FROM_ABI constexpr size_t size() noexcept { return sizeof...(_Ip); }	51
53	};	52	template <class _Tp, _Tp... _Indices>
		53	struct integer_sequence : __integer_sequence<_Tp, _Indices...> {};
54		54
55	template <size_t... _Ip>	55	template <size_t... _Ip>
56	using index_sequence = integer_sequence<size_t, _Ip...>;	56	using index_sequence = integer_sequence<size_t, _Ip...>;
57		57
58	# if __has_builtin(__make_integer_seq)
59
60	template <class _Tp, _Tp _Ep>	58	template <class _Tp, _Tp _Ep>
61	using make_integer_sequence _LIBCPP_NODEBUG = __make_integer_seq<integer_sequence, _Tp, _Ep>;	59	using make_integer_sequence _LIBCPP_NODEBUG = __make_integer_sequence_impl<integer_sequence, _Tp, _Ep>;
62
63	# elif __has_builtin(__integer_pack)
64
65	template <class _Tp, _Tp _SequenceSize>
66	using make_integer_sequence _LIBCPP_NODEBUG = integer_sequence<_Tp, __integer_pack(_SequenceSize)...>;
67
68	# else
69	# error "No known way to get an integer pack from the compiler"
70	# endif
71		60
72	template <size_t _Np>	61	template <size_t _Np>
73	using make_index_sequence = make_integer_sequence<size_t, _Np>;	62	using make_index_sequence = make_integer_sequence<size_t, _Np>;
...	@@ -75,16 +64,42 @@ using make_index_sequence = make_integer_sequence<size_t, _Np>;	...	@@ -75,16 +64,42 @@ using make_index_sequence = make_integer_sequence<size_t, _Np>;
75	template <class... _Tp>	64	template <class... _Tp>
76	using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;	65	using index_sequence_for = make_index_sequence<sizeof...(_Tp)>;
77		66
78	# if _LIBCPP_STD_VER >= 20	67	# if _LIBCPP_STD_VER >= 20
79	// Executes __func for every element in an index_sequence.	68	// Executes __func for every element in an index_sequence.
80	template <size_t... _Index, class _Function>	69	template <size_t... _Index, class _Function>
81	_LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) {	70	_LIBCPP_HIDE_FROM_ABI constexpr void __for_each_index_sequence(index_sequence<_Index...>, _Function __func) {
82	(__func.template operator()<_Index>(), ...);	71	(__func.template operator()<_Index>(), ...);
83	}	72	}
84	# endif // _LIBCPP_STD_VER >= 20	73	# endif // _LIBCPP_STD_VER >= 20
		74
		75	# if _LIBCPP_STD_VER >= 26
		76	// [intseq.binding], structured binding support
		77	template <class _Tp, _Tp... _Indices>
		78	struct tuple_size<integer_sequence<_Tp, _Indices...>> : integral_constant<size_t, sizeof...(_Indices)> {};
85		79
86	#endif // _LIBCPP_STD_VER >= 14	80	template <size_t _Ip, class _Tp, _Tp... _Indices>
		81	struct tuple_element<_Ip, integer_sequence<_Tp, _Indices...>> {
		82	static_assert(_Ip < sizeof...(_Indices), "Index out of bounds in std::tuple_element<> (std::integer_sequence)");
		83	using type _LIBCPP_NODEBUG = _Tp;
		84	};
		85
		86	template <size_t _Ip, class _Tp, _Tp... _Indices>
		87	struct tuple_element<_Ip, const integer_sequence<_Tp, _Indices...>> {
		88	static_assert(_Ip < sizeof...(_Indices), "Index out of bounds in std::tuple_element<> (const std::integer_sequence)");
		89	using type _LIBCPP_NODEBUG = _Tp;
		90	};
		91
		92	template <size_t _Ip, class _Tp, _Tp... _Indices>
		93	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp get(integer_sequence<_Tp, _Indices...>) noexcept {
		94	static_assert(_Ip < sizeof...(_Indices), "Index out of bounds in std::get<> (std::integer_sequence)");
		95	return _Indices...[_Ip];
		96	}
		97	# endif // _LIBCPP_STD_VER >= 26
		98
		99	# endif // _LIBCPP_STD_VER >= 14
87		100
88	_LIBCPP_END_NAMESPACE_STD	101	_LIBCPP_END_NAMESPACE_STD
89		102
		103	#endif // _LIBCPP_CXX03_LANG
		104
90	#endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H	105	#endif // _LIBCPP___UTILITY_INTEGER_SEQUENCE_H

lib/libcxx/include/__utility/lazy_synth_three_way_comparator.h created+120

...	@@ -0,0 +1,120 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___UTILITY_LAZY_SYNTH_THREE_WAY_COMPARATOR_H
10	#define _LIBCPP___UTILITY_LAZY_SYNTH_THREE_WAY_COMPARATOR_H
11
12	#include <__assert>
13	#include <__config>
14	#include <__type_traits/conjunction.h>
15	#include <__type_traits/desugars_to.h>
16	#include <__type_traits/enable_if.h>
17	#include <__utility/default_three_way_comparator.h>
18
19	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
20	# pragma GCC system_header
21	#endif
22
23	// This file implements a __lazy_synth_three_way_comparator, which tries to build an efficient three way comparison from
24	// a binary comparator. That is done in multiple steps:
25	// 1) Check whether the comparator desugars to a less-than operator
26	// If that is the case, check whether there exists a specialization of `__default_three_way_comparator`, which
27	// can be specialized to implement a three way comparator for the specific types.
28	// 2) Fall back to doing a lazy less than/greater than comparison
29
30	_LIBCPP_BEGIN_NAMESPACE_STD
31
32	template <class _Comparator, class _LHS, class _RHS>
33	struct __lazy_compare_result {
34	const _Comparator& __comp_;
35	const _LHS& __lhs_;
36	const _RHS& __rhs_;
37
38	_LIBCPP_HIDE_FROM_ABI
39	__lazy_compare_result(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator& __comp,
40	_LIBCPP_CTOR_LIFETIMEBOUND const _LHS& __lhs,
41	_LIBCPP_CTOR_LIFETIMEBOUND const _RHS& __rhs)
42	: __comp_(__comp), __lhs_(__lhs), __rhs_(__rhs) {}
43
44	_LIBCPP_HIDE_FROM_ABI bool __less() const {
45	bool __result = __comp_(__lhs_, __rhs_);
46	_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(__result ? !static_cast<bool>(__comp_(__rhs_, __lhs_)) : true,
47	"Comparator does not induce a strict weak ordering");
48	return __result;
49	}
50
51	_LIBCPP_HIDE_FROM_ABI bool __greater() const {
52	bool __result = __comp_(__rhs_, __lhs_);
53	_LIBCPP_ASSERT_SEMANTIC_REQUIREMENT(__result ? !static_cast<bool>(__comp_(__lhs_, __rhs_)) : true,
54	"Comparator does not induce a strict weak ordering");
55	return __result;
56	}
57	};
58
59	// This class provides three way comparison between _LHS and _RHS as efficiently as possible. This can be specialized if
60	// a comparator only compares part of the object, potentially allowing an efficient three way comparison between the
61	// subobjects. The specialization should use the __lazy_synth_three_way_comparator for the subobjects to achieve this.
62	template <class _Comparator, class _LHS, class _RHS, class = void>
63	struct __lazy_synth_three_way_comparator {
64	const _Comparator& __comp_;
65
66	_LIBCPP_HIDE_FROM_ABI __lazy_synth_three_way_comparator(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator& __comp)
67	: __comp_(__comp) {}
68
69	_LIBCPP_HIDE_FROM_ABI __lazy_compare_result<_Comparator, _LHS, _RHS>
70	operator()(_LIBCPP_LIFETIMEBOUND const _LHS& __lhs, _LIBCPP_LIFETIMEBOUND const _RHS& __rhs) const {
71	return __lazy_compare_result<_Comparator, _LHS, _RHS>(__comp_, __lhs, __rhs);
72	}
73	};
74
75	struct __eager_compare_result {
76	int __res_;
77
78	_LIBCPP_HIDE_FROM_ABI explicit __eager_compare_result(int __res) : __res_(__res) {}
79
80	_LIBCPP_HIDE_FROM_ABI bool __less() const { return __res_ < 0; }
81	_LIBCPP_HIDE_FROM_ABI bool __greater() const { return __res_ > 0; }
82	};
83
84	template <class _Comparator, class _LHS, class _RHS>
85	struct __lazy_synth_three_way_comparator<_Comparator,
86	_LHS,
87	_RHS,
88	__enable_if_t<_And<__desugars_to<__less_tag, _Comparator, _LHS, _RHS>,
89	__has_default_three_way_comparator<_LHS, _RHS> >::value> > {
90	// This lifetimebound annotation is technically incorrect, but other specializations actually capture the lifetime of
91	// the comparator.
92	_LIBCPP_HIDE_FROM_ABI __lazy_synth_three_way_comparator(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator&) {}
93
94	// Same comment as above.
95	_LIBCPP_HIDE_FROM_ABI static __eager_compare_result
96	operator()(_LIBCPP_LIFETIMEBOUND const _LHS& __lhs, _LIBCPP_LIFETIMEBOUND const _RHS& __rhs) {
97	return __eager_compare_result(__default_three_way_comparator<_LHS, _RHS>()(__lhs, __rhs));
98	}
99	};
100
101	template <class _Comparator, class _LHS, class _RHS>
102	struct __lazy_synth_three_way_comparator<_Comparator,
103	_LHS,
104	_RHS,
105	__enable_if_t<_And<__desugars_to<__greater_tag, _Comparator, _LHS, _RHS>,
106	__has_default_three_way_comparator<_LHS, _RHS> >::value> > {
107	// This lifetimebound annotation is technically incorrect, but other specializations actually capture the lifetime of
108	// the comparator.
109	_LIBCPP_HIDE_FROM_ABI __lazy_synth_three_way_comparator(_LIBCPP_CTOR_LIFETIMEBOUND const _Comparator&) {}
110
111	// Same comment as above.
112	_LIBCPP_HIDE_FROM_ABI static __eager_compare_result
113	operator()(_LIBCPP_LIFETIMEBOUND const _LHS& __lhs, _LIBCPP_LIFETIMEBOUND const _RHS& __rhs) {
114	return __eager_compare_result(-__default_three_way_comparator<_LHS, _RHS>()(__lhs, __rhs));
115	}
116	};
117
118	_LIBCPP_END_NAMESPACE_STD
119
120	#endif // _LIBCPP___UTILITY_LAZY_SYNTH_THREE_WAY_COMPARATOR_H

lib/libcxx/include/__utility/pair.h+22-25

 @@ -18,7 +18,6 @@
 #include <__fwd/array.h>
 #include <__fwd/pair.h>
 #include <__fwd/tuple.h>
-#include <__tuple/tuple_indices.h>
 #include <__tuple/tuple_like_no_subrange.h>
 #include <__tuple/tuple_size.h>
 #include <__type_traits/common_reference.h>
 @@ -32,14 +31,13 @@
 #include <__type_traits/is_implicitly_default_constructible.h>
 #include <__type_traits/is_nothrow_assignable.h>
 #include <__type_traits/is_nothrow_constructible.h>
-#include <__type_traits/is_replaceable.h>
-#include <__type_traits/is_same.h>
 #include <__type_traits/is_swappable.h>
 #include <__type_traits/is_trivially_relocatable.h>
 #include <__type_traits/nat.h>
 #include <__type_traits/unwrap_ref.h>
 #include <__utility/declval.h>
 #include <__utility/forward.h>
+#include <__utility/integer_sequence.h>
 #include <__utility/move.h>
 #include <__utility/piecewise_construct.h>
 @@ -102,7 +100,6 @@ struct pair
       __conditional_t<__libcpp_is_trivially_relocatable<_T1>::value && __libcpp_is_trivially_relocatable<_T2>::value,
                       pair,
                       void>;
-  using __replaceable _LIBCPP_NODEBUG = __conditional_t<__is_replaceable_v<_T1> && __is_replaceable_v<_T2>, pair, void>;
   _LIBCPP_HIDE_FROM_ABI pair(pair const&) = default;
   _LIBCPP_HIDE_FROM_ABI pair(pair&&)      = default;
 @@ -222,11 +219,7 @@ struct pair
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
   pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args, tuple<_Args2...> __second_args) noexcept(
       is_nothrow_constructible<first_type, _Args1...>::value && is_nothrow_constructible<second_type, _Args2...>::value)
-      : pair(__pc,
+      : pair(__pc, __first_args, __second_args, __index_sequence_for<_Args1...>(), __index_sequence_for<_Args2...>()) {}
-             __first_args,
-             __second_args,
-             typename __make_tuple_indices<sizeof...(_Args1)>::type(),
-             typename __make_tuple_indices<sizeof...(_Args2) >::type()) {}
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair&
   operator=(__conditional_t<is_copy_assignable<first_type>::value && is_copy_assignable<second_type>::value,
 @@ -440,8 +433,8 @@ private:
   pair(piecewise_construct_t,
        tuple<_Args1...>& __first_args,
        tuple<_Args2...>& __second_args,
-       __tuple_indices<_I1...>,
+       __index_sequence<_I1...>,
-       __tuple_indices<_I2...>)
+       __index_sequence<_I2...>)
       : first(std::forward<_Args1>(std::get<_I1>(__first_args))...),
         second(std::forward<_Args2>(std::get<_I2>(__second_args))...) {}
 #endif
 @@ -546,8 +539,8 @@ swap(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) noexcept(noexcept(__x
 #endif
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 pair<__unwrap_ref_decay_t<_T1>, __unwrap_ref_decay_t<_T2> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
-make_pair(_T1&& __t1, _T2&& __t2) {
+pair<__unwrap_ref_decay_t<_T1>, __unwrap_ref_decay_t<_T2> > make_pair(_T1&& __t1, _T2&& __t2) {
   return pair<__unwrap_ref_decay_t<_T1>, __unwrap_ref_decay_t<_T2> >(std::forward<_T1>(__t1), std::forward<_T2>(__t2));
 }
 @@ -619,67 +612,71 @@ struct __get_pair<1> {
 };
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>& __p) _NOEXCEPT {
   return __get_pair<_Ip>::get(__p);
 }
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(const pair<_T1, _T2>& __p) _NOEXCEPT {
   return __get_pair<_Ip>::get(__p);
 }
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(pair<_T1, _T2>&& __p) _NOEXCEPT {
   return __get_pair<_Ip>::get(std::move(__p));
 }
 template <size_t _Ip, class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
+_LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(const pair<_T1, _T2>&& __p) _NOEXCEPT {
   return __get_pair<_Ip>::get(std::move(__p));
 }
 #if _LIBCPP_STD_VER >= 14
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(pair<_T1, _T2>& __p) _NOEXCEPT {
   return __p.first;
 }
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
   return __p.first;
 }
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
   return std::forward<_T1&&>(__p.first);
 }
 template <class _T1, class _T2>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
   return std::forward<_T1 const&&>(__p.first);
 }
 template <class _T2, class _T1>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2& get(pair<_T1, _T2>& __p) _NOEXCEPT {
   return __p.second;
 }
 template <class _T2, class _T1>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const& get(pair<_T1, _T2> const& __p) _NOEXCEPT {
   return __p.second;
 }
 template <class _T2, class _T1>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2&& get(pair<_T1, _T2>&& __p) _NOEXCEPT {
   return std::forward<_T2&&>(__p.second);
 }
 template <class _T2, class _T1>
-inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T2 const&& get(pair<_T1, _T2> const&& __p) _NOEXCEPT {
   return std::forward<_T2 const&&>(__p.second);
 }

lib/libcxx/include/__utility/scope_guard.h+2

...	@@ -43,6 +43,8 @@ public:	...	@@ -43,6 +43,8 @@ public:
43	#endif	43	#endif
44	};	44	};
45		45
		46	_LIBCPP_CTAD_SUPPORTED_FOR_TYPE(__scope_guard);
		47
46	template <class _Func>	48	template <class _Func>
47	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __scope_guard<_Func> __make_scope_guard(_Func __func) {	49	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __scope_guard<_Func> __make_scope_guard(_Func __func) {
48	return __scope_guard<_Func>(std::move(__func));	50	return __scope_guard<_Func>(std::move(__func));

lib/libcxx/include/__utility/try_key_extraction.h created+114

...	@@ -0,0 +1,114 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP___UTILITY_TRY_EXTRACT_KEY_H
10	#define _LIBCPP___UTILITY_TRY_EXTRACT_KEY_H
11
12	#include <__config>
13	#include <__fwd/pair.h>
14	#include <__fwd/tuple.h>
15	#include <__type_traits/enable_if.h>
16	#include <__type_traits/is_same.h>
17	#include <__type_traits/remove_const.h>
18	#include <__type_traits/remove_const_ref.h>
19	#include <__utility/declval.h>
20	#include <__utility/forward.h>
21	#include <__utility/piecewise_construct.h>
22	#include <__utility/priority_tag.h>
23
24	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
25	# pragma GCC system_header
26	#endif
27
28	_LIBCPP_BEGIN_NAMESPACE_STD
29
30	template <class _KeyT, class _Ret, class _WithKey, class _WithoutKey, class... _Args>
31	_LIBCPP_HIDE_FROM_ABI _Ret
32	__try_key_extraction_impl(__priority_tag<0>, _WithKey, _WithoutKey __without_key, _Args&&... __args) {
33	return __without_key(std::forward<_Args>(__args)...);
34	}
35
36	template <class _KeyT,
37	class _Ret,
38	class _WithKey,
39	class _WithoutKey,
40	class _Arg,
41	__enable_if_t<is_same<_KeyT, __remove_const_ref_t<_Arg> >::value, int> = 0>
42	_LIBCPP_HIDE_FROM_ABI _Ret
43	__try_key_extraction_impl(__priority_tag<1>, _WithKey __with_key, _WithoutKey, _Arg&& __arg) {
44	return __with_key(__arg, std::forward<_Arg>(__arg));
45	}
46
47	template <class _KeyT,
48	class _Ret,
49	class _WithKey,
50	class _WithoutKey,
51	class _Arg,
52	__enable_if_t<__is_pair_v<__remove_const_ref_t<_Arg> > &&
53	is_same<__remove_const_t<typename __remove_const_ref_t<_Arg>::first_type>, _KeyT>::value,
54	int> = 0>
55	_LIBCPP_HIDE_FROM_ABI _Ret
56	__try_key_extraction_impl(__priority_tag<1>, _WithKey __with_key, _WithoutKey, _Arg&& __arg) {
57	return __with_key(__arg.first, std::forward<_Arg>(__arg));
58	}
59
60	template <class _KeyT,
61	class _Ret,
62	class _WithKey,
63	class _WithoutKey,
64	class _Arg1,
65	class _Arg2,
66	__enable_if_t<is_same<_KeyT, __remove_const_ref_t<_Arg1> >::value, int> = 0>
67	_LIBCPP_HIDE_FROM_ABI _Ret
68	__try_key_extraction_impl(__priority_tag<1>, _WithKey __with_key, _WithoutKey, _Arg1&& __arg1, _Arg2&& __arg2) {
69	return __with_key(__arg1, std::forward<_Arg1>(__arg1), std::forward<_Arg2>(__arg2));
70	}
71
72	#ifndef _LIBCPP_CXX03_LANG
73	template <class _KeyT,
74	class _Ret,
75	class _WithKey,
76	class _WithoutKey,
77	class _PiecewiseConstruct,
78	class _Tuple1,
79	class _Tuple2,
80	__enable_if_t<is_same<__remove_const_ref_t<_PiecewiseConstruct>, piecewise_construct_t>::value &&
81	__is_tuple_v<_Tuple1> && tuple_size<_Tuple1>::value == 1 &&
82	is_same<__remove_const_ref_t<typename tuple_element<0, _Tuple1>::type>, _KeyT>::value,
83	int> = 0>
84	_LIBCPP_HIDE_FROM_ABI _Ret __try_key_extraction_impl(
85	__priority_tag<1>,
86	_WithKey __with_key,
87	_WithoutKey,
88	_PiecewiseConstruct&& __pc,
89	_Tuple1&& __tuple1,
90	_Tuple2&& __tuple2) {
91	return __with_key(
92	std::get<0>(__tuple1),
93	std::forward<_PiecewiseConstruct>(__pc),
94	std::forward<_Tuple1>(__tuple1),
95	std::forward<_Tuple2>(__tuple2));
96	}
97	#endif // _LIBCPP_CXX03_LANG
98
99	// This function tries extracting the given _KeyT from _Args...
100	// If it succeeds to extract the key, it calls the `__with_key` function with the extracted key and all of the
101	// arguments. Otherwise it calls the `__without_key` function with all of the arguments.
102	//
103	// Both `__with_key` and `__without_key` must take all arguments by reference.
104	template <class _KeyT, class _WithKey, class _WithoutKey, class... _Args>
105	_LIBCPP_HIDE_FROM_ABI decltype(std::declval<_WithoutKey>()(std::declval<_Args>()...))
106	__try_key_extraction(_WithKey __with_key, _WithoutKey __without_key, _Args&&... __args) {
107	using _Ret = decltype(__without_key(std::forward<_Args>(__args)...));
108	return std::__try_key_extraction_impl<_KeyT, _Ret>(
109	__priority_tag<1>(), __with_key, __without_key, std::forward<_Args>(__args)...);
110	}
111
112	_LIBCPP_END_NAMESPACE_STD
113
114	#endif // _LIBCPP___UTILITY_TRY_EXTRACT_KEY_H

lib/libcxx/include/__vector/vector.h+187-160

...	@@ -12,18 +12,17 @@	...	@@ -12,18 +12,17 @@
12	#include <__algorithm/copy.h>	12	#include <__algorithm/copy.h>
13	#include <__algorithm/copy_n.h>	13	#include <__algorithm/copy_n.h>
14	#include <__algorithm/fill_n.h>	14	#include <__algorithm/fill_n.h>
		15	#include <__algorithm/iterator_operations.h>
15	#include <__algorithm/max.h>	16	#include <__algorithm/max.h>
16	#include <__algorithm/min.h>	17	#include <__algorithm/min.h>
17	#include <__algorithm/move.h>	18	#include <__algorithm/move.h>
18	#include <__algorithm/move_backward.h>	19	#include <__algorithm/move_backward.h>
19	#include <__algorithm/ranges_copy_n.h>
20	#include <__algorithm/rotate.h>	20	#include <__algorithm/rotate.h>
21	#include <__assert>	21	#include <__assert>
22	#include <__config>	22	#include <__config>
23	#include <__debug_utils/sanitizers.h>	23	#include <__debug_utils/sanitizers.h>
24	#include <__format/enable_insertable.h>	24	#include <__format/enable_insertable.h>
25	#include <__fwd/vector.h>	25	#include <__fwd/vector.h>
26	#include <__iterator/advance.h>
27	#include <__iterator/bounded_iter.h>	26	#include <__iterator/bounded_iter.h>
28	#include <__iterator/concepts.h>	27	#include <__iterator/concepts.h>
29	#include <__iterator/distance.h>	28	#include <__iterator/distance.h>
...	@@ -43,6 +42,7 @@	...	@@ -43,6 +42,7 @@
43	#include <__memory/temp_value.h>	42	#include <__memory/temp_value.h>
44	#include <__memory/uninitialized_algorithms.h>	43	#include <__memory/uninitialized_algorithms.h>
45	#include <__ranges/access.h>	44	#include <__ranges/access.h>
		45	#include <__ranges/as_rvalue_view.h>
46	#include <__ranges/concepts.h>	46	#include <__ranges/concepts.h>
47	#include <__ranges/container_compatible_range.h>	47	#include <__ranges/container_compatible_range.h>
48	#include <__ranges/from_range.h>	48	#include <__ranges/from_range.h>
...	@@ -55,7 +55,6 @@	...	@@ -55,7 +55,6 @@
55	#include <__type_traits/is_nothrow_assignable.h>	55	#include <__type_traits/is_nothrow_assignable.h>
56	#include <__type_traits/is_nothrow_constructible.h>	56	#include <__type_traits/is_nothrow_constructible.h>
57	#include <__type_traits/is_pointer.h>	57	#include <__type_traits/is_pointer.h>
58	#include <__type_traits/is_replaceable.h>
59	#include <__type_traits/is_same.h>	58	#include <__type_traits/is_same.h>
60	#include <__type_traits/is_trivially_relocatable.h>	59	#include <__type_traits/is_trivially_relocatable.h>
61	#include <__type_traits/type_identity.h>	60	#include <__type_traits/type_identity.h>
...	@@ -86,6 +85,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -86,6 +85,9 @@ _LIBCPP_BEGIN_NAMESPACE_STD
86		85
87	template <class _Tp, class _Allocator /* = allocator<_Tp> */>	86	template <class _Tp, class _Allocator /* = allocator<_Tp> */>
88	class vector {	87	class vector {
		88	template <class _Up, class _Alloc>
		89	using __split_buffer _LIBCPP_NODEBUG = std::__split_buffer<_Up, _Alloc, __split_buffer_pointer_layout>;
		90
89	public:	91	public:
90	//	92	//
91	// Types	93	// Types
...	@@ -113,7 +115,7 @@ public:	...	@@ -113,7 +115,7 @@ public:
113	using reverse_iterator = std::reverse_iterator<iterator>;	115	using reverse_iterator = std::reverse_iterator<iterator>;
114	using const_reverse_iterator = std::reverse_iterator<const_iterator>;	116	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
115		117
116	// A vector containers the following members which may be trivially relocatable:	118	// A vector contains the following members which may be trivially relocatable:
117	// - pointer: may be trivially relocatable, so it's checked	119	// - pointer: may be trivially relocatable, so it's checked
118	// - allocator_type: may be trivially relocatable, so it's checked	120	// - allocator_type: may be trivially relocatable, so it's checked
119	// vector doesn't contain any self-references, so it's trivially relocatable if its members are.	121	// vector doesn't contain any self-references, so it's trivially relocatable if its members are.
...	@@ -121,10 +123,6 @@ public:	...	@@ -121,10 +123,6 @@ public:
121	__libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,	123	__libcpp_is_trivially_relocatable<pointer>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,
122	vector,	124	vector,
123	void>;	125	void>;
124	using __replaceable _LIBCPP_NODEBUG =
125	__conditional_t<__is_replaceable_v<pointer> && __container_allocator_is_replaceable<__alloc_traits>::value,
126	vector,
127	void>;
128		126
129	static_assert(__check_valid_allocator<allocator_type>::value, "");	127	static_assert(__check_valid_allocator<allocator_type>::value, "");
130	static_assert(is_same<typename allocator_type::value_type, value_type>::value,	128	static_assert(is_same<typename allocator_type::value_type, value_type>::value,
...	@@ -174,7 +172,7 @@ public:	...	@@ -174,7 +172,7 @@ public:
174	__guard.__complete();	172	__guard.__complete();
175	}	173	}
176		174
177	template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>	175	template <__enable_if_t<__is_allocator_v<_Allocator>, int> = 0>
178	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI	176	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI
179	vector(size_type __n, const value_type& __x, const allocator_type& __a)	177	vector(size_type __n, const value_type& __x, const allocator_type& __a)
180	: __alloc_(__a) {	178	: __alloc_(__a) {
...	@@ -317,7 +315,7 @@ public:	...	@@ -317,7 +315,7 @@ public:
317	is_constructible<value_type, typename iterator_traits<_ForwardIterator>::reference>::value,	315	is_constructible<value_type, typename iterator_traits<_ForwardIterator>::reference>::value,
318	int> = 0>	316	int> = 0>
319	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(_ForwardIterator __first, _ForwardIterator __last) {	317	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void assign(_ForwardIterator __first, _ForwardIterator __last) {
320	__assign_with_size(__first, __last, std::distance(__first, __last));	318	__assign_with_size<_ClassicAlgPolicy>(__first, __last, std::distance(__first, __last));
321	}	319	}
322		320
323	#if _LIBCPP_STD_VER >= 23	321	#if _LIBCPP_STD_VER >= 23
...	@@ -325,7 +323,7 @@ public:	...	@@ -325,7 +323,7 @@ public:
325	_LIBCPP_HIDE_FROM_ABI constexpr void assign_range(_Range&& __range) {	323	_LIBCPP_HIDE_FROM_ABI constexpr void assign_range(_Range&& __range) {
326	if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {	324	if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {
327	auto __n = static_cast<size_type>(ranges::distance(__range));	325	auto __n = static_cast<size_type>(ranges::distance(__range));
328	__assign_with_size(ranges::begin(__range), ranges::end(__range), __n);	326	__assign_with_size<_RangeAlgPolicy>(ranges::begin(__range), ranges::end(__range), __n);
329		327
330	} else {	328	} else {
331	__assign_with_sentinel(ranges::begin(__range), ranges::end(__range));	329	__assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
...	@@ -341,59 +339,67 @@ public:	...	@@ -341,59 +339,67 @@ public:
341	}	339	}
342	#endif	340	#endif
343		341
344	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {	342	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
345	return this->__alloc_;	343	return this->__alloc_;
346	}	344	}
347		345
348	//	346	//
349	// Iterators	347	// Iterators
350	//	348	//
351	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {	349	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
352	return __make_iter(__add_alignment_assumption(this->__begin_));	350	return __make_iter(__add_alignment_assumption(this->__begin_));
353	}	351	}
354	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {	352	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
355	return __make_iter(__add_alignment_assumption(this->__begin_));	353	return __make_iter(__add_alignment_assumption(this->__begin_));
356	}	354	}
357	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {	355	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {
358	return __make_iter(__add_alignment_assumption(this->__end_));	356	return __make_iter(__add_alignment_assumption(this->__end_));
359	}	357	}
360	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {	358	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
361	return __make_iter(__add_alignment_assumption(this->__end_));	359	return __make_iter(__add_alignment_assumption(this->__end_));
362	}	360	}
363		361
364	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT {	362	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT {
365	return reverse_iterator(end());	363	return reverse_iterator(end());
366	}	364	}
367	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {	365	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator
		366	rbegin() const _NOEXCEPT {
368	return const_reverse_iterator(end());	367	return const_reverse_iterator(end());
369	}	368	}
370	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT {	369	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT {
371	return reverse_iterator(begin());	370	return reverse_iterator(begin());
372	}	371	}
373	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {	372	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
374	return const_reverse_iterator(begin());	373	return const_reverse_iterator(begin());
375	}	374	}
376		375
377	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }	376	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
378	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }	377	return begin();
379	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {	378	}
		379	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
		380	return end();
		381	}
		382	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator
		383	crbegin() const _NOEXCEPT {
380	return rbegin();	384	return rbegin();
381	}	385	}
382	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }	386	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
		387	return rend();
		388	}
383		389
384	//	390	//
385	// [vector.capacity], capacity	391	// [vector.capacity], capacity
386	//	392	//
387	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT {	393	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT {
388	return static_cast<size_type>(this->__end_ - this->__begin_);	394	return static_cast<size_type>(this->__end_ - this->__begin_);
389	}	395	}
390	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type capacity() const _NOEXCEPT {	396	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type capacity() const _NOEXCEPT {
391	return static_cast<size_type>(this->__cap_ - this->__begin_);	397	return static_cast<size_type>(this->__cap_ - this->__begin_);
392	}	398	}
393	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT {	399	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT {
394	return this->__begin_ == this->__end_;	400	return this->__begin_ == this->__end_;
395	}	401	}
396	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {	402	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
397	return std::min<size_type>(__alloc_traits::max_size(this->__alloc_), numeric_limits<difference_type>::max());	403	return std::min<size_type>(__alloc_traits::max_size(this->__alloc_), numeric_limits<difference_type>::max());
398	}	404	}
399	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n);	405	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n);
...	@@ -402,38 +408,39 @@ public:	...	@@ -402,38 +408,39 @@ public:
402	//	408	//
403	// element access	409	// element access
404	//	410	//
405	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference operator[](size_type __n) _NOEXCEPT {	411	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference operator[](size_type __n) _NOEXCEPT {
406	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector[] index out of bounds");	412	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector[] index out of bounds");
407	return this->__begin_[__n];	413	return this->__begin_[__n];
408	}	414	}
409	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const _NOEXCEPT {	415	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference
		416	operator[](size_type __n) const _NOEXCEPT {
410	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector[] index out of bounds");	417	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector[] index out of bounds");
411	return this->__begin_[__n];	418	return this->__begin_[__n];
412	}	419	}
413	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference at(size_type __n) {	420	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference at(size_type __n) {
414	if (__n >= size())	421	if (__n >= size())
415	this->__throw_out_of_range();	422	this->__throw_out_of_range();
416	return this->__begin_[__n];	423	return this->__begin_[__n];
417	}	424	}
418	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const {	425	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __n) const {
419	if (__n >= size())	426	if (__n >= size())
420	this->__throw_out_of_range();	427	this->__throw_out_of_range();
421	return this->__begin_[__n];	428	return this->__begin_[__n];
422	}	429	}
423		430
424	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference front() _NOEXCEPT {	431	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference front() _NOEXCEPT {
425	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "front() called on an empty vector");	432	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "front() called on an empty vector");
426	return *this->__begin_;	433	return *this->__begin_;
427	}	434	}
428	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {	435	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
429	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "front() called on an empty vector");	436	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "front() called on an empty vector");
430	return *this->__begin_;	437	return *this->__begin_;
431	}	438	}
432	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT {	439	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT {
433	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "back() called on an empty vector");	440	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "back() called on an empty vector");
434	return *(this->__end_ - 1);	441	return *(this->__end_ - 1);
435	}	442	}
436	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {	443	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
437	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "back() called on an empty vector");	444	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "back() called on an empty vector");
438	return *(this->__end_ - 1);	445	return *(this->__end_ - 1);
439	}	446	}
...	@@ -441,11 +448,11 @@ public:	...	@@ -441,11 +448,11 @@ public:
441	//	448	//
442	// [vector.data], data access	449	// [vector.data], data access
443	//	450	//
444	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI value_type* data() _NOEXCEPT {	451	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI value_type* data() _NOEXCEPT {
445	return std::__to_address(this->__begin_);	452	return std::__to_address(this->__begin_);
446	}	453	}
447		454
448	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const value_type* data() const _NOEXCEPT {	455	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI const value_type* data() const _NOEXCEPT {
449	return std::__to_address(this->__begin_);	456	return std::__to_address(this->__begin_);
450	}	457	}
451		458
...	@@ -478,7 +485,21 @@ public:	...	@@ -478,7 +485,21 @@ public:
478	#if _LIBCPP_STD_VER >= 23	485	#if _LIBCPP_STD_VER >= 23
479	template <_ContainerCompatibleRange<_Tp> _Range>	486	template <_ContainerCompatibleRange<_Tp> _Range>
480	_LIBCPP_HIDE_FROM_ABI constexpr void append_range(_Range&& __range) {	487	_LIBCPP_HIDE_FROM_ABI constexpr void append_range(_Range&& __range) {
481	insert_range(end(), std::forward<_Range>(__range));	488	if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {
		489	auto __len = ranges::distance(__range);
		490	if (__len <= __cap_ - __end_) {
		491	__construct_at_end(ranges::begin(__range), ranges::end(__range), __len);
		492	} else {
		493	__split_buffer<value_type, allocator_type> __buffer(__recommend(size() + __len), size(), __alloc_);
		494	__buffer.__construct_at_end_with_size(ranges::begin(__range), __len);
		495	__swap_out_circular_buffer(__buffer);
		496	}
		497	} else {
		498	vector __buffer(__alloc_);
		499	for (auto&& __val : __range)
		500	__buffer.emplace_back(std::forward<decltype(__val)>(__val));
		501	append_range(ranges::as_rvalue_view(__buffer));
		502	}
482	}	503	}
483	#endif	504	#endif
484		505
...	@@ -512,7 +533,7 @@ public:	...	@@ -512,7 +533,7 @@ public:
512	int> = 0>	533	int> = 0>
513	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator	534	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
514	insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) {	535	insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last) {
515	return __insert_with_size(__position, __first, __last, std::distance(__first, __last));	536	return __insert_with_size<_ClassicAlgPolicy>(__position, __first, __last, std::distance(__first, __last));
516	}	537	}
517		538
518	#if _LIBCPP_STD_VER >= 23	539	#if _LIBCPP_STD_VER >= 23
...	@@ -520,7 +541,7 @@ public:	...	@@ -520,7 +541,7 @@ public:
520	_LIBCPP_HIDE_FROM_ABI constexpr iterator insert_range(const_iterator __position, _Range&& __range) {	541	_LIBCPP_HIDE_FROM_ABI constexpr iterator insert_range(const_iterator __position, _Range&& __range) {
521	if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {	542	if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {
522	auto __n = static_cast<size_type>(ranges::distance(__range));	543	auto __n = static_cast<size_type>(ranges::distance(__range));
523	return __insert_with_size(__position, ranges::begin(__range), ranges::end(__range), __n);	544	return __insert_with_size<_RangeAlgPolicy>(__position, ranges::begin(__range), ranges::end(__range), __n);
524		545
525	} else {	546	} else {
526	return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));	547	return __insert_with_sentinel(__position, ranges::begin(__range), ranges::end(__range));
...	@@ -613,12 +634,13 @@ private:	...	@@ -613,12 +634,13 @@ private:
613	// The `_Iterator` in `_with_size` functions can be input-only only if called from `_range` (since C++23).	634	// The `_Iterator` in `_with_size` functions can be input-only only if called from `_range` (since C++23).
614	// Otherwise, `_Iterator` is a forward iterator.	635	// Otherwise, `_Iterator` is a forward iterator.
615		636
616	template <class _Iterator, class _Sentinel>	637	template <class _AlgPolicy, class _Iterator, class _Sentinel>
617	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	638	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
618	__assign_with_size(_Iterator __first, _Sentinel __last, difference_type __n);	639	__assign_with_size(_Iterator __first, _Sentinel __last, difference_type __n);
619		640
620	template <class _Iterator,	641	template <class _AlgPolicy,
621	__enable_if_t<!is_same<decltype(*std::declval<_Iterator&>())&&, value_type&&>::value, int> = 0>	642	class _Iterator,
		643	__enable_if_t<!is_same<__policy_value_type<_AlgPolicy, _Iterator>, value_type>::value, int> = 0>
622	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	644	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
623	__insert_assign_n_unchecked(_Iterator __first, difference_type __n, pointer __position) {	645	__insert_assign_n_unchecked(_Iterator __first, difference_type __n, pointer __position) {
624	for (pointer __end_position = __position + __n; __position != __end_position; ++__position, (void)++__first) {	646	for (pointer __end_position = __position + __n; __position != __end_position; ++__position, (void)++__first) {
...	@@ -627,25 +649,19 @@ private:	...	@@ -627,25 +649,19 @@ private:
627	}	649	}
628	}	650	}
629		651
630	template <class _Iterator,	652	template <class _AlgPolicy,
631	__enable_if_t<is_same<decltype(*std::declval<_Iterator&>())&&, value_type&&>::value, int> = 0>	653	class _Iterator,
		654	__enable_if_t<is_same<__policy_value_type<_AlgPolicy, _Iterator>, value_type>::value, int> = 0>
632	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	655	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
633	__insert_assign_n_unchecked(_Iterator __first, difference_type __n, pointer __position) {	656	__insert_assign_n_unchecked(_Iterator __first, difference_type __n, pointer __position) {
634	#if _LIBCPP_STD_VER >= 23	657	std::__copy_n<_AlgPolicy>(std::move(__first), __n, __position);
635	if constexpr (!forward_iterator<_Iterator>) { // Handles input-only sized ranges for insert_range
636	ranges::copy_n(std::move(__first), __n, __position);
637	} else
638	#endif
639	{
640	std::copy_n(__first, __n, __position);
641	}
642	}	658	}
643		659
644	template <class _InputIterator, class _Sentinel>	660	template <class _InputIterator, class _Sentinel>
645	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator	661	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
646	__insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);	662	__insert_with_sentinel(const_iterator __position, _InputIterator __first, _Sentinel __last);
647		663
648	template <class _Iterator, class _Sentinel>	664	template <class _AlgPolicy, class _Iterator, class _Sentinel>
649	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator	665	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator
650	__insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);	666	__insert_with_size(const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n);
651		667
...	@@ -653,9 +669,6 @@ private:	...	@@ -653,9 +669,6 @@ private:
653	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	669	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
654	__construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);	670	__construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);
655		671
656	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n);
657	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __append(size_type __n, const_reference __x);
658
659	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator __make_iter(pointer __p) _NOEXCEPT {	672	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI iterator __make_iter(pointer __p) _NOEXCEPT {
660	#ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_VECTOR	673	#ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_VECTOR
661	// Bound the iterator according to the capacity, rather than the size.	674	// Bound the iterator according to the capacity, rather than the size.
...	@@ -689,9 +702,9 @@ private:	...	@@ -689,9 +702,9 @@ private:
689	}	702	}
690		703
691	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	704	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
692	__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);	705	__swap_out_circular_buffer(__split_buffer<value_type, allocator_type>& __v);
693	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer	706	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI pointer
694	__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);	707	__swap_out_circular_buffer(__split_buffer<value_type, allocator_type>& __v, pointer __p);
695	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	708	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
696	__move_range(pointer __from_s, pointer __from_e, pointer __to);	709	__move_range(pointer __from_s, pointer __from_e, pointer __to);
697	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign(vector& __c, true_type)	710	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __move_assign(vector& __c, true_type)
...	@@ -811,26 +824,44 @@ private:	...	@@ -811,26 +824,44 @@ private:
811	__add_alignment_assumption(_Ptr __p) _NOEXCEPT {	824	__add_alignment_assumption(_Ptr __p) _NOEXCEPT {
812	return __p;	825	return __p;
813	}	826	}
		827
		828	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void __swap_layouts(__split_buffer<_Tp, allocator_type>& __sb) {
		829	auto __vector_begin = __begin_;
		830	auto __vector_sentinel = __end_;
		831	auto __vector_cap = __cap_;
		832
		833	auto __sb_begin = __sb.begin();
		834	auto __sb_sentinel = __sb.__raw_sentinel();
		835	auto __sb_cap = __sb.__raw_capacity();
		836
		837	// TODO: replace with __set_valid_range and __set_capacity when vector supports it.
		838	__begin_ = __sb_begin;
		839	__end_ = __sb_sentinel;
		840	__cap_ = __sb_cap;
		841
		842	__sb.__set_valid_range(__vector_begin, __vector_sentinel);
		843	__sb.__set_capacity(__vector_cap);
		844	}
814	};	845	};
815		846
816	#if _LIBCPP_STD_VER >= 17	847	#if _LIBCPP_STD_VER >= 17
817	template <class _InputIterator,	848	template <class _InputIterator,
818	class _Alloc = allocator<__iter_value_type<_InputIterator>>,	849	class _Alloc = allocator<__iterator_value_type<_InputIterator>>,
819	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,	850	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
820	class = enable_if_t<__is_allocator<_Alloc>::value> >	851	class = enable_if_t<__is_allocator_v<_Alloc>>>
821	vector(_InputIterator, _InputIterator) -> vector<__iter_value_type<_InputIterator>, _Alloc>;	852	vector(_InputIterator, _InputIterator) -> vector<__iterator_value_type<_InputIterator>, _Alloc>;
822		853
823	template <class _InputIterator,	854	template <class _InputIterator,
824	class _Alloc,	855	class _Alloc,
825	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,	856	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
826	class = enable_if_t<__is_allocator<_Alloc>::value> >	857	class = enable_if_t<__is_allocator_v<_Alloc>>>
827	vector(_InputIterator, _InputIterator, _Alloc) -> vector<__iter_value_type<_InputIterator>, _Alloc>;	858	vector(_InputIterator, _InputIterator, _Alloc) -> vector<__iterator_value_type<_InputIterator>, _Alloc>;
828	#endif	859	#endif
829		860
830	#if _LIBCPP_STD_VER >= 23	861	#if _LIBCPP_STD_VER >= 23
831	template <ranges::input_range _Range,	862	template <ranges::input_range _Range,
832	class _Alloc = allocator<ranges::range_value_t<_Range>>,	863	class _Alloc = allocator<ranges::range_value_t<_Range>>,
833	class = enable_if_t<__is_allocator<_Alloc>::value> >	864	class = enable_if_t<__is_allocator_v<_Alloc>>>
834	vector(from_range_t, _Range&&, _Alloc = _Alloc()) -> vector<ranges::range_value_t<_Range>, _Alloc>;	865	vector(from_range_t, _Range&&, _Alloc = _Alloc()) -> vector<ranges::range_value_t<_Range>, _Alloc>;
835	#endif	866	#endif
836		867
...	@@ -839,17 +870,16 @@ vector(from_range_t, _Range&&, _Alloc = _Alloc()) -> vector<ranges::range_value_	...	@@ -839,17 +870,16 @@ vector(from_range_t, _Range&&, _Alloc = _Alloc()) -> vector<ranges::range_value_
839	// function has a strong exception guarantee.	870	// function has a strong exception guarantee.
840	template <class _Tp, class _Allocator>	871	template <class _Tp, class _Allocator>
841	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	872	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
842	vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v) {	873	vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type>& __v) {
843	__annotate_delete();	874	__annotate_delete();
844	auto __new_begin = __v.__begin_ - (__end_ - __begin_);	875	auto __new_begin = __v.begin() - size();
845	std::__uninitialized_allocator_relocate(	876	std::__uninitialized_allocator_relocate(
846	this->__alloc_, std::__to_address(__begin_), std::__to_address(__end_), std::__to_address(__new_begin));	877	this->__alloc_, std::__to_address(__begin_), std::__to_address(__end_), std::__to_address(__new_begin));
847	__v.__begin_ = __new_begin;	878	__v.__set_valid_range(__new_begin, __v.end());
848	__end_ = __begin_; // All the objects have been destroyed by relocating them.	879	__end_ = __begin_; // All the objects have been destroyed by relocating them.
849	std::swap(this->__begin_, __v.__begin_);	880
850	std::swap(this->__end_, __v.__end_);	881	__swap_layouts(__v);
851	std::swap(this->__cap_, __v.__cap_);	882	__v.__set_data(__v.begin());
852	__v.__first_ = __v.__begin_;
853	__annotate_new(size());	883	__annotate_new(size());
854	}	884	}
855		885
...	@@ -859,27 +889,25 @@ vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, a	...	@@ -859,27 +889,25 @@ vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, a
859	// function has a strong exception guarantee if __begin_ == __p \|\| __end_ == __p.	889	// function has a strong exception guarantee if __begin_ == __p \|\| __end_ == __p.
860	template <class _Tp, class _Allocator>	890	template <class _Tp, class _Allocator>
861	_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer	891	_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer
862	vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p) {	892	vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type>& __v, pointer __p) {
863	__annotate_delete();	893	__annotate_delete();
864	pointer __ret = __v.__begin_;	894	pointer __ret = __v.begin();
865		895
866	// Relocate [__p, __end_) first to avoid having a hole in [__begin_, __end_)	896	// Relocate [__p, __end_) first to avoid having a hole in [__begin_, __end_)
867	// in case something in [__begin_, __p) throws.	897	// in case something in [__begin_, __p) throws.
868	std::__uninitialized_allocator_relocate(	898	std::__uninitialized_allocator_relocate(
869	this->__alloc_, std::__to_address(__p), std::__to_address(__end_), std::__to_address(__v.__end_));	899	this->__alloc_, std::__to_address(__p), std::__to_address(__end_), std::__to_address(__v.end()));
870	__v.__end_ += (__end_ - __p);	900	auto __relocated_so_far = __end_ - __p;
		901	__v.__set_sentinel(__v.end() + __relocated_so_far);
871	__end_ = __p; // The objects in [__p, __end_) have been destroyed by relocating them.	902	__end_ = __p; // The objects in [__p, __end_) have been destroyed by relocating them.
872	auto __new_begin = __v.__begin_ - (__p - __begin_);	903	auto __new_begin = __v.begin() - (__p - __begin_);
873		904
874	std::__uninitialized_allocator_relocate(	905	std::__uninitialized_allocator_relocate(
875	this->__alloc_, std::__to_address(__begin_), std::__to_address(__p), std::__to_address(__new_begin));	906	this->__alloc_, std::__to_address(__begin_), std::__to_address(__p), std::__to_address(__new_begin));
876	__v.__begin_ = __new_begin;	907	__v.__set_valid_range(__new_begin, __v.end());
877	__end_ = __begin_; // All the objects have been destroyed by relocating them.	908	__end_ = __begin_; // All the objects have been destroyed by relocating them.
878		909	__swap_layouts(__v);
879	std::swap(this->__begin_, __v.__begin_);	910	__v.__set_data(__v.begin());
880	std::swap(this->__end_, __v.__end_);
881	std::swap(this->__cap_, __v.__cap_);
882	__v.__first_ = __v.__begin_;
883	__annotate_new(size());	911	__annotate_new(size());
884	return __ret;	912	return __ret;
885	}	913	}
...	@@ -945,36 +973,6 @@ vector<_Tp, _Allocator>::__construct_at_end(_InputIterator __first, _Sentinel __	...	@@ -945,36 +973,6 @@ vector<_Tp, _Allocator>::__construct_at_end(_InputIterator __first, _Sentinel __
945	__tx.__pos_ = std::__uninitialized_allocator_copy(this->__alloc_, std::move(__first), std::move(__last), __tx.__pos_);	973	__tx.__pos_ = std::__uninitialized_allocator_copy(this->__alloc_, std::move(__first), std::move(__last), __tx.__pos_);
946	}	974	}
947		975
948	// Default constructs __n objects starting at __end_
949	// throws if construction throws
950	// Postcondition: size() == size() + __n
951	// Exception safety: strong.
952	template <class _Tp, class _Allocator>
953	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__append(size_type __n) {
954	if (static_cast<size_type>(this->__cap_ - this->__end_) >= __n)
955	this->__construct_at_end(__n);
956	else {
957	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), this->__alloc_);
958	__v.__construct_at_end(__n);
959	__swap_out_circular_buffer(__v);
960	}
961	}
962
963	// Default constructs __n objects starting at __end_
964	// throws if construction throws
965	// Postcondition: size() == size() + __n
966	// Exception safety: strong.
967	template <class _Tp, class _Allocator>
968	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::__append(size_type __n, const_reference __x) {
969	if (static_cast<size_type>(this->__cap_ - this->__end_) >= __n)
970	this->__construct_at_end(__n, __x);
971	else {
972	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), size(), this->__alloc_);
973	__v.__construct_at_end(__n, __x);
974	__swap_out_circular_buffer(__v);
975	}
976	}
977
978	template <class _Tp, class _Allocator>	976	template <class _Tp, class _Allocator>
979	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI vector<_Tp, _Allocator>::vector(vector&& __x)	977	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline _LIBCPP_HIDE_FROM_ABI vector<_Tp, _Allocator>::vector(vector&& __x)
980	#if _LIBCPP_STD_VER >= 17	978	#if _LIBCPP_STD_VER >= 17
...	@@ -1051,20 +1049,14 @@ vector<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __l	...	@@ -1051,20 +1049,14 @@ vector<_Tp, _Allocator>::__assign_with_sentinel(_Iterator __first, _Sentinel __l
1051	}	1049	}
1052		1050
1053	template <class _Tp, class _Allocator>	1051	template <class _Tp, class _Allocator>
1054	template <class _Iterator, class _Sentinel>	1052	template <class _AlgPolicy, class _Iterator, class _Sentinel>
1055	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	1053	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
1056	vector<_Tp, _Allocator>::__assign_with_size(_Iterator __first, _Sentinel __last, difference_type __n) {	1054	vector<_Tp, _Allocator>::__assign_with_size(_Iterator __first, _Sentinel __last, difference_type __n) {
1057	size_type __new_size = static_cast<size_type>(__n);	1055	size_type __new_size = static_cast<size_type>(__n);
1058	if (__new_size <= capacity()) {	1056	if (__new_size <= capacity()) {
1059	if (__new_size > size()) {	1057	if (__new_size > size()) {
1060	#if _LIBCPP_STD_VER >= 23	1058	auto __mid = std::__copy_n<_AlgPolicy>(std::move(__first), size(), this->__begin_).first;
1061	auto __mid = ranges::copy_n(std::move(__first), size(), this->__begin_).in;
1062	__construct_at_end(std::move(__mid), std::move(__last), __new_size - size());	1059	__construct_at_end(std::move(__mid), std::move(__last), __new_size - size());
1063	#else
1064	_Iterator __mid = std::next(__first, size());
1065	std::copy(__first, __mid, this->__begin_);
1066	__construct_at_end(__mid, __last, __new_size - size());
1067	#endif
1068	} else {	1060	} else {
1069	pointer __m = std::__copy(std::move(__first), __last, this->__begin_).second;	1061	pointer __m = std::__copy(std::move(__first), __last, this->__begin_).second;
1070	this->__destruct_at_end(__m);	1062	this->__destruct_at_end(__m);
...	@@ -1097,7 +1089,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::reserve(size_type __	...	@@ -1097,7 +1089,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::reserve(size_type __
1097	if (__n > capacity()) {	1089	if (__n > capacity()) {
1098	if (__n > max_size())	1090	if (__n > max_size())
1099	this->__throw_length_error();	1091	this->__throw_length_error();
1100	__split_buffer<value_type, allocator_type&> __v(__n, size(), this->__alloc_);	1092	__split_buffer<value_type, allocator_type> __v(__n, size(), this->__alloc_);
1101	__swap_out_circular_buffer(__v);	1093	__swap_out_circular_buffer(__v);
1102	}	1094	}
1103	}	1095	}
...	@@ -1108,7 +1100,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::shrink_to_fit() _NOE	...	@@ -1108,7 +1100,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::shrink_to_fit() _NOE
1108	#if _LIBCPP_HAS_EXCEPTIONS	1100	#if _LIBCPP_HAS_EXCEPTIONS
1109	try {	1101	try {
1110	#endif // _LIBCPP_HAS_EXCEPTIONS	1102	#endif // _LIBCPP_HAS_EXCEPTIONS
1111	__split_buffer<value_type, allocator_type&> __v(size(), size(), this->__alloc_);	1103	__split_buffer<value_type, allocator_type> __v(size(), size(), this->__alloc_);
1112	// The Standard mandates shrink_to_fit() does not increase the capacity.	1104	// The Standard mandates shrink_to_fit() does not increase the capacity.
1113	// With equal capacity keep the existing buffer. This avoids extra work	1105	// With equal capacity keep the existing buffer. This avoids extra work
1114	// due to swapping the elements.	1106	// due to swapping the elements.
...	@@ -1125,14 +1117,33 @@ template <class _Tp, class _Allocator>	...	@@ -1125,14 +1117,33 @@ template <class _Tp, class _Allocator>
1125	template <class... _Args>	1117	template <class... _Args>
1126	_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer	1118	_LIBCPP_CONSTEXPR_SINCE_CXX20 typename vector<_Tp, _Allocator>::pointer
1127	vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args) {	1119	vector<_Tp, _Allocator>::__emplace_back_slow_path(_Args&&... __args) {
1128	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), this->__alloc_);	1120	__split_buffer<value_type, allocator_type> __v(__recommend(size() + 1), size(), this->__alloc_);
1129	// __v.emplace_back(std::forward<_Args>(__args)...);	1121	// __v.emplace_back(std::forward<_Args>(__args)...);
1130	__alloc_traits::construct(this->__alloc_, std::__to_address(__v.__end_), std::forward<_Args>(__args)...);	1122	pointer __end = __v.end();
1131	__v.__end_++;	1123	__alloc_traits::construct(this->__alloc_, std::__to_address(__end), std::forward<_Args>(__args)...);
		1124	__v.__set_sentinel(++__end);
1132	__swap_out_circular_buffer(__v);	1125	__swap_out_circular_buffer(__v);
1133	return this->__end_;	1126	return this->__end_;
1134	}	1127	}
1135		1128
		1129	// This makes the compiler inline `__else()` if `__cond` is known to be false. Currently LLVM doesn't do that without
		1130	// the `__builtin_constant_p`, since it considers `__else` unlikely even through it's known to be run.
		1131	// See https://llvm.org/PR154292
		1132	template <class _If, class _Else>
		1133	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __if_likely_else(bool __cond, _If __if, _Else __else) {
		1134	if (__builtin_constant_p(__cond)) {
		1135	if (__cond)
		1136	__if();
		1137	else
		1138	__else();
		1139	} else {
		1140	if (__cond) [[__likely__]]
		1141	__if();
		1142	else
		1143	__else();
		1144	}
		1145	}
		1146
1136	template <class _Tp, class _Allocator>	1147	template <class _Tp, class _Allocator>
1137	template <class... _Args>	1148	template <class... _Args>
1138	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline	1149	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline
...	@@ -1143,12 +1154,14 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 inline	...	@@ -1143,12 +1154,14 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 inline
1143	#endif	1154	#endif
1144	vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) {	1155	vector<_Tp, _Allocator>::emplace_back(_Args&&... __args) {
1145	pointer __end = this->__end_;	1156	pointer __end = this->__end_;
1146	if (__end < this->__cap_) {	1157	std::__if_likely_else(
1147	__emplace_back_assume_capacity(std::forward<_Args>(__args)...);	1158	__end < this->__cap_,
1148	++__end;	1159	[&] {
1149	} else {	1160	__emplace_back_assume_capacity(std::forward<_Args>(__args)...);
1150	__end = __emplace_back_slow_path(std::forward<_Args>(__args)...);	1161	++__end;
1151	}	1162	},
		1163	[&] { __end = __emplace_back_slow_path(std::forward<_Args>(__args)...); });
		1164
1152	this->__end_ = __end;	1165	this->__end_ = __end;
1153	#if _LIBCPP_STD_VER >= 17	1166	#if _LIBCPP_STD_VER >= 17
1154	return *(__end - 1);	1167	return *(__end - 1);
...	@@ -1207,7 +1220,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)	...	@@ -1207,7 +1220,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
1207	__p = __xr;	1220	__p = __xr;
1208	}	1221	}
1209	} else {	1222	} else {
1210	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, this->__alloc_);	1223	__split_buffer<value_type, allocator_type> __v(__recommend(size() + 1), __p - this->__begin_, this->__alloc_);
1211	__v.emplace_back(__x);	1224	__v.emplace_back(__x);
1212	__p = __swap_out_circular_buffer(__v, __p);	1225	__p = __swap_out_circular_buffer(__v, __p);
1213	}	1226	}
...	@@ -1226,7 +1239,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x) {	...	@@ -1226,7 +1239,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x) {
1226	*__p = std::move(__x);	1239	*__p = std::move(__x);
1227	}	1240	}
1228	} else {	1241	} else {
1229	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, this->__alloc_);	1242	__split_buffer<value_type, allocator_type> __v(__recommend(size() + 1), __p - this->__begin_, this->__alloc_);
1230	__v.emplace_back(std::move(__x));	1243	__v.emplace_back(std::move(__x));
1231	__p = __swap_out_circular_buffer(__v, __p);	1244	__p = __swap_out_circular_buffer(__v, __p);
1232	}	1245	}
...	@@ -1247,7 +1260,7 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args) {	...	@@ -1247,7 +1260,7 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args) {
1247	*__p = std::move(__tmp.get());	1260	*__p = std::move(__tmp.get());
1248	}	1261	}
1249	} else {	1262	} else {
1250	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, this->__alloc_);	1263	__split_buffer<value_type, allocator_type> __v(__recommend(size() + 1), __p - this->__begin_, this->__alloc_);
1251	__v.emplace_back(std::forward<_Args>(__args)...);	1264	__v.emplace_back(std::forward<_Args>(__args)...);
1252	__p = __swap_out_circular_buffer(__v, __p);	1265	__p = __swap_out_circular_buffer(__v, __p);
1253	}	1266	}
...	@@ -1275,7 +1288,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_	...	@@ -1275,7 +1288,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_
1275	std::fill_n(__p, __n, *__xr);	1288	std::fill_n(__p, __n, *__xr);
1276	}	1289	}
1277	} else {	1290	} else {
1278	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, this->__alloc_);	1291	__split_buffer<value_type, allocator_type> __v(__recommend(size() + __n), __p - this->__begin_, this->__alloc_);
1279	__v.__construct_at_end(__n, __x);	1292	__v.__construct_at_end(__n, __x);
1280	__p = __swap_out_circular_buffer(__v, __p);	1293	__p = __swap_out_circular_buffer(__v, __p);
1281	}	1294	}
...	@@ -1296,28 +1309,28 @@ vector<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __position, _Inpu	...	@@ -1296,28 +1309,28 @@ vector<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __position, _Inpu
1296	if (__first == __last)	1309	if (__first == __last)
1297	(void)std::rotate(__p, __old_last, this->__end_);	1310	(void)std::rotate(__p, __old_last, this->__end_);
1298	else {	1311	else {
1299	__split_buffer<value_type, allocator_type&> __v(__alloc_);	1312	__split_buffer<value_type, allocator_type> __v(__alloc_);
1300	auto __guard = std::__make_exception_guard(	1313	auto __guard = std::__make_exception_guard(
1301	_AllocatorDestroyRangeReverse<allocator_type, pointer>(__alloc_, __old_last, this->__end_));	1314	_AllocatorDestroyRangeReverse<allocator_type, pointer>(__alloc_, __old_last, this->__end_));
1302	__v.__construct_at_end_with_sentinel(std::move(__first), std::move(__last));	1315	__v.__construct_at_end_with_sentinel(std::move(__first), std::move(__last));
1303	__split_buffer<value_type, allocator_type&> __merged(	1316	__split_buffer<value_type, allocator_type> __merged(
1304	__recommend(size() + __v.size()), __off, __alloc_); // has `__off` positions available at the front	1317	__recommend(size() + __v.size()), __off, __alloc_); // has `__off` positions available at the front
1305	std::__uninitialized_allocator_relocate(	1318	std::__uninitialized_allocator_relocate(
1306	__alloc_, std::__to_address(__old_last), std::__to_address(this->__end_), std::__to_address(__merged.__end_));	1319	__alloc_, std::__to_address(__old_last), std::__to_address(this->__end_), std::__to_address(__merged.end()));
1307	__guard.__complete(); // Release the guard once objects in [__old_last_, __end_) have been successfully relocated.	1320	__guard.__complete(); // Release the guard once objects in [__old_last_, __end_) have been successfully relocated.
1308	__merged.__end_ += this->__end_ - __old_last;	1321	__merged.__set_sentinel(__merged.end() + (this->__end_ - __old_last));
1309	this->__end_ = __old_last;	1322	this->__end_ = __old_last;
1310	std::__uninitialized_allocator_relocate(	1323	std::__uninitialized_allocator_relocate(
1311	__alloc_, std::__to_address(__v.__begin_), std::__to_address(__v.__end_), std::__to_address(__merged.__end_));	1324	__alloc_, std::__to_address(__v.begin()), std::__to_address(__v.end()), std::__to_address(__merged.end()));
1312	__merged.__end_ += __v.size();	1325	__merged.__set_sentinel(__merged.size() + __v.size());
1313	__v.__end_ = __v.__begin_;	1326	__v.__set_sentinel(__v.begin());
1314	__p = __swap_out_circular_buffer(__merged, __p);	1327	__p = __swap_out_circular_buffer(__merged, __p);
1315	}	1328	}
1316	return __make_iter(__p);	1329	return __make_iter(__p);
1317	}	1330	}
1318		1331
1319	template <class _Tp, class _Allocator>	1332	template <class _Tp, class _Allocator>
1320	template <class _Iterator, class _Sentinel>	1333	template <class _AlgPolicy, class _Iterator, class _Sentinel>
1321	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator	1334	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI typename vector<_Tp, _Allocator>::iterator
1322	vector<_Tp, _Allocator>::__insert_with_size(	1335	vector<_Tp, _Allocator>::__insert_with_size(
1323	const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n) {	1336	const_iterator __position, _Iterator __first, _Sentinel __last, difference_type __n) {
...	@@ -1338,15 +1351,15 @@ vector<_Tp, _Allocator>::__insert_with_size(	...	@@ -1338,15 +1351,15 @@ vector<_Tp, _Allocator>::__insert_with_size(
1338	__construct_at_end(__m, __last, __n - __dx);	1351	__construct_at_end(__m, __last, __n - __dx);
1339	if (__dx > 0) {	1352	if (__dx > 0) {
1340	__move_range(__p, __old_last, __p + __n);	1353	__move_range(__p, __old_last, __p + __n);
1341	__insert_assign_n_unchecked(__first, __dx, __p);	1354	__insert_assign_n_unchecked<_AlgPolicy>(__first, __dx, __p);
1342	}	1355	}
1343	}	1356	}
1344	} else {	1357	} else {
1345	__move_range(__p, __old_last, __p + __n);	1358	__move_range(__p, __old_last, __p + __n);
1346	__insert_assign_n_unchecked(std::move(__first), __n, __p);	1359	__insert_assign_n_unchecked<_AlgPolicy>(std::move(__first), __n, __p);
1347	}	1360	}
1348	} else {	1361	} else {
1349	__split_buffer<value_type, allocator_type&> __v(__recommend(size() + __n), __p - this->__begin_, this->__alloc_);	1362	__split_buffer<value_type, allocator_type> __v(__recommend(size() + __n), __p - this->__begin_, this->__alloc_);
1350	__v.__construct_at_end_with_size(std::move(__first), __n);	1363	__v.__construct_at_end_with_size(std::move(__first), __n);
1351	__p = __swap_out_circular_buffer(__v, __p);	1364	__p = __swap_out_circular_buffer(__v, __p);
1352	}	1365	}
...	@@ -1355,21 +1368,35 @@ vector<_Tp, _Allocator>::__insert_with_size(	...	@@ -1355,21 +1368,35 @@ vector<_Tp, _Allocator>::__insert_with_size(
1355	}	1368	}
1356		1369
1357	template <class _Tp, class _Allocator>	1370	template <class _Tp, class _Allocator>
1358	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::resize(size_type __sz) {	1371	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::resize(size_type __new_size) {
1359	size_type __cs = size();	1372	size_type __current_size = size();
1360	if (__cs < __sz)	1373	if (__current_size < __new_size) {
1361	this->__append(__sz - __cs);	1374	if (__new_size <= capacity()) {
1362	else if (__cs > __sz)	1375	__construct_at_end(__new_size - __current_size);
1363	this->__destruct_at_end(this->__begin_ + __sz);	1376	} else {
		1377	__split_buffer<value_type, allocator_type> __v(__recommend(__new_size), __current_size, __alloc_);
		1378	__v.__construct_at_end(__new_size - __current_size);
		1379	__swap_out_circular_buffer(__v);
		1380	}
		1381	} else if (__current_size > __new_size) {
		1382	this->__destruct_at_end(this->__begin_ + __new_size);
		1383	}
1364	}	1384	}
1365		1385
1366	template <class _Tp, class _Allocator>	1386	template <class _Tp, class _Allocator>
1367	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::resize(size_type __sz, const_reference __x) {	1387	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<_Tp, _Allocator>::resize(size_type __new_size, const_reference __x) {
1368	size_type __cs = size();	1388	size_type __current_size = size();
1369	if (__cs < __sz)	1389	if (__current_size < __new_size) {
1370	this->__append(__sz - __cs, __x);	1390	if (__new_size <= capacity())
1371	else if (__cs > __sz)	1391	__construct_at_end(__new_size - __current_size, __x);
1372	this->__destruct_at_end(this->__begin_ + __sz);	1392	else {
		1393	__split_buffer<value_type, allocator_type> __v(__recommend(__new_size), __current_size, __alloc_);
		1394	__v.__construct_at_end(__new_size - __current_size, __x);
		1395	__swap_out_circular_buffer(__v);
		1396	}
		1397	} else if (__current_size > __new_size) {
		1398	this->__destruct_at_end(this->__begin_ + __new_size);
		1399	}
1373	}	1400	}
1374		1401
1375	template <class _Tp, class _Allocator>	1402	template <class _Tp, class _Allocator>

lib/libcxx/include/__vector/vector_bool.h+76-83

...	@@ -11,6 +11,7 @@	...	@@ -11,6 +11,7 @@
11		11
12	#include <__algorithm/copy.h>	12	#include <__algorithm/copy.h>
13	#include <__algorithm/copy_backward.h>	13	#include <__algorithm/copy_backward.h>
		14	#include <__algorithm/copy_n.h>
14	#include <__algorithm/fill_n.h>	15	#include <__algorithm/fill_n.h>
15	#include <__algorithm/iterator_operations.h>	16	#include <__algorithm/iterator_operations.h>
16	#include <__algorithm/max.h>	17	#include <__algorithm/max.h>
...	@@ -19,7 +20,7 @@	...	@@ -19,7 +20,7 @@
19	#include <__bit_reference>	20	#include <__bit_reference>
20	#include <__config>	21	#include <__config>
21	#include <__functional/unary_function.h>	22	#include <__functional/unary_function.h>
22	#include <__fwd/bit_reference.h> // TODO: This is a workaround for https://github.com/llvm/llvm-project/issues/131814	23	#include <__fwd/bit_reference.h> // TODO: This is a workaround for https://llvm.org/PR131814
23	#include <__fwd/functional.h>	24	#include <__fwd/functional.h>
24	#include <__fwd/vector.h>	25	#include <__fwd/vector.h>
25	#include <__iterator/distance.h>	26	#include <__iterator/distance.h>
...	@@ -234,74 +235,89 @@ public:	...	@@ -234,74 +235,89 @@ public:
234	}	235	}
235	#endif	236	#endif
236		237
237	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT {	238	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT {
238	return allocator_type(this->__alloc_);	239	return allocator_type(this->__alloc_);
239	}	240	}
240		241
241	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT;	242	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT;
242	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {	243	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {
243	return __internal_cap_to_external(__cap_);	244	return __internal_cap_to_external(__cap_);
244	}	245	}
245	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT { return __size_; }	246	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT {
		247	return __size_;
		248	}
246	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool empty() const _NOEXCEPT {	249	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 bool empty() const _NOEXCEPT {
247	return __size_ == 0;	250	return __size_ == 0;
248	}	251	}
249	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __n);	252	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reserve(size_type __n);
250	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void shrink_to_fit() _NOEXCEPT;	253	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void shrink_to_fit() _NOEXCEPT;
251		254
252	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() _NOEXCEPT { return __make_iter(0); }	255	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() _NOEXCEPT {
253	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator begin() const _NOEXCEPT { return __make_iter(0); }	256	return __make_iter(0);
254	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() _NOEXCEPT { return __make_iter(__size_); }	257	}
255	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator end() const _NOEXCEPT {	258	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator begin() const _NOEXCEPT {
		259	return __make_iter(0);
		260	}
		261	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() _NOEXCEPT {
		262	return __make_iter(__size_);
		263	}
		264	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator end() const _NOEXCEPT {
256	return __make_iter(__size_);	265	return __make_iter(__size_);
257	}	266	}
258		267
259	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rbegin() _NOEXCEPT {	268	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rbegin() _NOEXCEPT {
260	return reverse_iterator(end());	269	return reverse_iterator(end());
261	}	270	}
262	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rbegin() const _NOEXCEPT {	271	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator
		272	rbegin() const _NOEXCEPT {
263	return const_reverse_iterator(end());	273	return const_reverse_iterator(end());
264	}	274	}
265	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rend() _NOEXCEPT {	275	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rend() _NOEXCEPT {
266	return reverse_iterator(begin());	276	return reverse_iterator(begin());
267	}	277	}
268	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rend() const _NOEXCEPT {	278	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rend() const _NOEXCEPT {
269	return const_reverse_iterator(begin());	279	return const_reverse_iterator(begin());
270	}	280	}
271		281
272	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cbegin() const _NOEXCEPT { return __make_iter(0); }	282	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cbegin() const _NOEXCEPT {
273	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cend() const _NOEXCEPT {	283	return __make_iter(0);
		284	}
		285	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cend() const _NOEXCEPT {
274	return __make_iter(__size_);	286	return __make_iter(__size_);
275	}	287	}
276	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crbegin() const _NOEXCEPT {	288	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator
		289	crbegin() const _NOEXCEPT {
277	return rbegin();	290	return rbegin();
278	}	291	}
279	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }	292	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crend() const _NOEXCEPT {
		293	return rend();
		294	}
280		295
281	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](size_type __n) {	296	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](size_type __n) {
282	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector<bool>::operator[] index out of bounds");	297	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector<bool>::operator[] index out of bounds");
283	return __make_ref(__n);	298	return __make_ref(__n);
284	}	299	}
285	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference operator[](size_type __n) const {	300	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference
		301	operator[](size_type __n) const {
286	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector<bool>::operator[] index out of bounds");	302	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < size(), "vector<bool>::operator[] index out of bounds");
287	return __make_ref(__n);	303	return __make_ref(__n);
288	}	304	}
289	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference at(size_type __n);	305	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference at(size_type __n);
290	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference at(size_type __n) const;	306	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference at(size_type __n) const;
291		307
292	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() {	308	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() {
293	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::front() called on an empty vector");	309	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::front() called on an empty vector");
294	return __make_ref(0);	310	return __make_ref(0);
295	}	311	}
296	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const {	312	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const {
297	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::front() called on an empty vector");	313	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::front() called on an empty vector");
298	return __make_ref(0);	314	return __make_ref(0);
299	}	315	}
300	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() {	316	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() {
301	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::back() called on an empty vector");	317	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::back() called on an empty vector");
302	return __make_ref(__size_ - 1);	318	return __make_ref(__size_ - 1);
303	}	319	}
304	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const {	320	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const {
305	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::back() called on an empty vector");	321	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "vector<bool>::back() called on an empty vector");
306	return __make_ref(__size_ - 1);	322	return __make_ref(__size_ - 1);
307	}	323	}
...	@@ -463,7 +479,6 @@ private:	...	@@ -463,7 +479,6 @@ private:
463	return (__new_size + (__bits_per_word - 1)) & ~((size_type)__bits_per_word - 1);	479	return (__new_size + (__bits_per_word - 1)) & ~((size_type)__bits_per_word - 1);
464	}	480	}
465	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __recommend(size_type __new_size) const;	481	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __recommend(size_type __new_size) const;
466	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct_at_end(size_type __n, bool __x);
467	template <class _InputIterator, class _Sentinel>	482	template <class _InputIterator, class _Sentinel>
468	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void	483	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
469	__construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);	484	__construct_at_end(_InputIterator __first, _Sentinel __last, size_type __n);
...	@@ -552,20 +567,6 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const {	...	@@ -552,20 +567,6 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const {
552	return std::max<size_type>(2 * __cap, __align_it(__new_size));	567	return std::max<size_type>(2 * __cap, __align_it(__new_size));
553	}	568	}
554		569
555	// Default constructs __n objects starting at __end_
556	// Precondition: size() + __n <= capacity()
557	// Postcondition: size() == size() + __n
558	template <class _Allocator>
559	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
560	vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x) {
561	_LIBCPP_ASSERT_INTERNAL(
562	capacity() >= size() + __n, "vector<bool>::__construct_at_end called with insufficient capacity");
563	std::fill_n(end(), __n, __x);
564	this->__size_ += __n;
565	if (end().__ctz_ != 0) // Ensure uninitialized leading bits in the last word are set to zero
566	std::fill_n(end(), __bits_per_word - end().__ctz_, 0);
567	}
568
569	template <class _Allocator>	570	template <class _Allocator>
570	template <class _InputIterator, class _Sentinel>	571	template <class _InputIterator, class _Sentinel>
571	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	572	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
...	@@ -598,7 +599,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n)	...	@@ -598,7 +599,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n)
598	: __begin_(nullptr), __size_(0), __cap_(0) {	599	: __begin_(nullptr), __size_(0), __cap_(0) {
599	if (__n > 0) {	600	if (__n > 0) {
600	__vallocate(__n);	601	__vallocate(__n);
601	__construct_at_end(__n, false);	602	std::fill_n(__begin_, __external_cap_to_internal(__n), __storage_type(0));
		603	__size_ = __n;
602	}	604	}
603	}	605	}
604		606
...	@@ -608,7 +610,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n, co	...	@@ -608,7 +610,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n, co
608	: __begin_(nullptr), __size_(0), __cap_(0), __alloc_(static_cast<__storage_allocator>(__a)) {	610	: __begin_(nullptr), __size_(0), __cap_(0), __alloc_(static_cast<__storage_allocator>(__a)) {
609	if (__n > 0) {	611	if (__n > 0) {
610	__vallocate(__n);	612	__vallocate(__n);
611	__construct_at_end(__n, false);	613	std::fill_n(__begin_, __external_cap_to_internal(__n), __storage_type(0));
		614	__size_ = __n;
612	}	615	}
613	}	616	}
614	#endif	617	#endif
...	@@ -618,7 +621,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n, co	...	@@ -618,7 +621,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(size_type __n, co
618	: __begin_(nullptr), __size_(0), __cap_(0) {	621	: __begin_(nullptr), __size_(0), __cap_(0) {
619	if (__n > 0) {	622	if (__n > 0) {
620	__vallocate(__n);	623	__vallocate(__n);
621	__construct_at_end(__n, __x);	624	std::fill_n(__begin_, __external_cap_to_internal(__n), __storage_type(0) - __x);
		625	__size_ = __n;
622	}	626	}
623	}	627	}
624		628
...	@@ -628,7 +632,8 @@ vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const all	...	@@ -628,7 +632,8 @@ vector<bool, _Allocator>::vector(size_type __n, const value_type& __x, const all
628	: __begin_(nullptr), __size_(0), __cap_(0), __alloc_(static_cast<__storage_allocator>(__a)) {	632	: __begin_(nullptr), __size_(0), __cap_(0), __alloc_(static_cast<__storage_allocator>(__a)) {
629	if (__n > 0) {	633	if (__n > 0) {
630	__vallocate(__n);	634	__vallocate(__n);
631	__construct_at_end(__n, __x);	635	std::fill_n(__begin_, __external_cap_to_internal(__n), __storage_type(0) - __x);
		636	__size_ = __n;
632	}	637	}
633	}	638	}
634		639
...	@@ -697,7 +702,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v	...	@@ -697,7 +702,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v
697	__alloc_(__storage_traits::select_on_container_copy_construction(__v.__alloc_)) {	702	__alloc_(__storage_traits::select_on_container_copy_construction(__v.__alloc_)) {
698	if (__v.size() > 0) {	703	if (__v.size() > 0) {
699	__vallocate(__v.size());	704	__vallocate(__v.size());
700	__construct_at_end(__v.begin(), __v.end(), __v.size());	705	std::copy_n(__v.__begin_, __external_cap_to_internal(__v.size()), __begin_);
		706	__size_ = __v.size();
701	}	707	}
702	}	708	}
703		709
...	@@ -706,7 +712,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v	...	@@ -706,7 +712,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>::vector(const vector& __v
706	: __begin_(nullptr), __size_(0), __cap_(0), __alloc_(__a) {	712	: __begin_(nullptr), __size_(0), __cap_(0), __alloc_(__a) {
707	if (__v.size() > 0) {	713	if (__v.size() > 0) {
708	__vallocate(__v.size());	714	__vallocate(__v.size());
709	__construct_at_end(__v.begin(), __v.end(), __v.size());	715	std::copy_n(__v.__begin_, __external_cap_to_internal(__v.size()), __begin_);
		716	__size_ = __v.size();
710	}	717	}
711	}	718	}
712		719
...	@@ -719,7 +726,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>& vector<bool, _Allocator>	...	@@ -719,7 +726,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 vector<bool, _Allocator>& vector<bool, _Allocator>
719	__vdeallocate();	726	__vdeallocate();
720	__vallocate(__v.__size_);	727	__vallocate(__v.__size_);
721	}	728	}
722	std::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);	729	std::copy_n(__v.__begin_, __external_cap_to_internal(__v.size()), __begin_);
723	}	730	}
724	__size_ = __v.__size_;	731	__size_ = __v.__size_;
725	}	732	}
...	@@ -754,7 +761,8 @@ vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator	...	@@ -754,7 +761,8 @@ vector<bool, _Allocator>::vector(vector&& __v, const __type_identity_t<allocator
754	__v.__cap_ = __v.__size_ = 0;	761	__v.__cap_ = __v.__size_ = 0;
755	} else if (__v.size() > 0) {	762	} else if (__v.size() > 0) {
756	__vallocate(__v.size());	763	__vallocate(__v.size());
757	__construct_at_end(__v.begin(), __v.end(), __v.size());	764	__size_ = __v.__size_;
		765	std::copy_n(__v.__begin_, __external_cap_to_internal(__v.size()), __begin_);
758	}	766	}
759	}	767	}
760		768
...	@@ -849,7 +857,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::reserve(size_type _	...	@@ -849,7 +857,8 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::reserve(size_type _
849	this->__throw_length_error();	857	this->__throw_length_error();
850	vector __v(this->get_allocator());	858	vector __v(this->get_allocator());
851	__v.__vallocate(__n);	859	__v.__vallocate(__n);
852	__v.__construct_at_end(this->begin(), this->end(), this->size());	860	__v.__size_ = __size_;
		861	std::copy_n(__begin_, __external_cap_to_internal(__size_), __v.__begin_);
853	swap(__v);	862	swap(__v);
854	}	863	}
855	}	864	}
...	@@ -956,21 +965,14 @@ vector<bool, _Allocator>::__insert_with_sentinel(const_iterator __position, _Inp	...	@@ -956,21 +965,14 @@ vector<bool, _Allocator>::__insert_with_sentinel(const_iterator __position, _Inp
956	}	965	}
957	vector __v(get_allocator());	966	vector __v(get_allocator());
958	if (__first != __last) {	967	if (__first != __last) {
959	#if _LIBCPP_HAS_EXCEPTIONS	968	auto __guard = std::__make_exception_guard([&] { erase(__old_end, end()); });
960	try {	969	__v.__assign_with_sentinel(std::move(__first), std::move(__last));
961	#endif // _LIBCPP_HAS_EXCEPTIONS	970	difference_type __old_size = static_cast<difference_type>(__old_end - begin());
962	__v.__assign_with_sentinel(std::move(__first), std::move(__last));	971	difference_type __old_p = __p - begin();
963	difference_type __old_size = static_cast<difference_type>(__old_end - begin());	972	reserve(__recommend(size() + __v.size()));
964	difference_type __old_p = __p - begin();	973	__p = begin() + __old_p;
965	reserve(__recommend(size() + __v.size()));	974	__old_end = begin() + __old_size;
966	__p = begin() + __old_p;	975	__guard.__complete();
967	__old_end = begin() + __old_size;
968	#if _LIBCPP_HAS_EXCEPTIONS
969	} catch (...) {
970	erase(__old_end, end());
971	throw;
972	}
973	#endif // _LIBCPP_HAS_EXCEPTIONS
974	}	976	}
975	__p = std::rotate(__p, __old_end, end());	977	__p = std::rotate(__p, __old_end, end());
976	insert(__p, __v.begin(), __v.end());	978	insert(__p, __v.begin(), __v.end());
...	@@ -1048,25 +1050,16 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::swap(vector& __x)	...	@@ -1048,25 +1050,16 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::swap(vector& __x)
1048	}	1050	}
1049		1051
1050	template <class _Allocator>	1052	template <class _Allocator>
1051	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::resize(size_type __sz, value_type __x) {	1053	_LIBCPP_CONSTEXPR_SINCE_CXX20 void vector<bool, _Allocator>::resize(size_type __new_size, value_type __x) {
1052	size_type __cs = size();	1054	size_type __current_size = size();
1053	if (__cs < __sz) {	1055	if (__new_size < __current_size) {
1054	iterator __r;	1056	__size_ = __new_size;
1055	size_type __c = capacity();	1057	return;
1056	size_type __n = __sz - __cs;	1058	}
1057	if (__n <= __c && __cs <= __c - __n) {	1059
1058	__r = end();	1060	reserve(__new_size);
1059	__size_ += __n;	1061	std::fill_n(end(), __new_size - __current_size, __x);
1060	} else {	1062	__size_ = __new_size;
1061	vector __v(get_allocator());
1062	__v.reserve(__recommend(__size_ + __n));
1063	__v.__size_ = __size_ + __n;
1064	__r = std::copy(cbegin(), cend(), __v.begin());
1065	swap(__v);
1066	}
1067	std::fill_n(__r, __n, __x);
1068	} else
1069	__size_ = __sz;
1070	}	1063	}
1071		1064
1072	template <class _Allocator>	1065	template <class _Allocator>

lib/libcxx/include/any+118-155

 @@ -84,14 +84,12 @@ namespace std {
 #  include <__cxx03/__config>
 #else
 #  include <__config>
-#  include <__memory/allocator.h>
+#  include <__memory/construct_at.h>
-#  include <__memory/allocator_destructor.h>
+#  include <__new/allocate.h>
-#  include <__memory/allocator_traits.h>
-#  include <__memory/unique_ptr.h>
 #  include <__type_traits/add_cv_quals.h>
 #  include <__type_traits/add_pointer.h>
-#  include <__type_traits/aligned_storage.h>
 #  include <__type_traits/conditional.h>
+#  include <__type_traits/conjunction.h>
 #  include <__type_traits/decay.h>
 #  include <__type_traits/enable_if.h>
 #  include <__type_traits/is_constructible.h>
 @@ -100,9 +98,11 @@ namespace std {
 #  include <__type_traits/is_reference.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_void.h>
+#  include <__type_traits/negation.h>
 #  include <__type_traits/remove_cv.h>
 #  include <__type_traits/remove_cvref.h>
 #  include <__type_traits/remove_reference.h>
+#  include <__utility/exception_guard.h>
 #  include <__utility/forward.h>
 #  include <__utility/in_place.h>
 #  include <__utility/move.h>
 @@ -142,21 +142,20 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 class any;
 template <class _ValueType>
-_LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) _NOEXCEPT;
+_LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) noexcept;
 template <class _ValueType>
-_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any*) _NOEXCEPT;
+_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any*) noexcept;
 namespace __any_imp {
-_LIBCPP_SUPPRESS_DEPRECATED_PUSH
+inline constexpr size_t __small_buffer_size      = 3 * sizeof(void*);
-using _Buffer _LIBCPP_NODEBUG = aligned_storage_t<3 * sizeof(void*), alignof(void*)>;
+inline constexpr size_t __small_buffer_alignment = alignof(void*);
-_LIBCPP_SUPPRESS_DEPRECATED_POP
 template <class _Tp>
 using _IsSmallObject _LIBCPP_NODEBUG =
     integral_constant<bool,
-                      sizeof(_Tp) <= sizeof(_Buffer) && alignof(_Buffer) % alignof(_Tp) == 0 &&
+                      sizeof(_Tp) <= __small_buffer_size && alignof(_Tp) <= __small_buffer_alignment &&
-                          is_nothrow_move_constructible<_Tp>::value >;
+                          is_nothrow_move_constructible_v<_Tp>>;
 enum class _Action { _Destroy, _Copy, _Move, _Get, _TypeInfo };
 @@ -192,37 +191,44 @@ using _Handler _LIBCPP_NODEBUG = conditional_t< _IsSmallObject<_Tp>::value, _Sma
 class any {
 public:
   // construct/destruct
-  _LIBCPP_HIDE_FROM_ABI constexpr any() _NOEXCEPT : __h_(nullptr) {}
+  _LIBCPP_HIDE_FROM_ABI constexpr any() noexcept : __h_(nullptr) {}
   _LIBCPP_HIDE_FROM_ABI any(any const& __other) : __h_(nullptr) {
     if (__other.__h_)
       __other.__call(_Action::_Copy, this);
   }
-  _LIBCPP_HIDE_FROM_ABI any(any&& __other) _NOEXCEPT : __h_(nullptr) {
+  _LIBCPP_HIDE_FROM_ABI any(any&& __other) noexcept : __h_(nullptr) {
     if (__other.__h_)
       __other.__call(_Action::_Move, this);
   }
-  template < class _ValueType,
+  template <
-             class _Tp = decay_t<_ValueType>,
+      class _ValueType,
-             class     = enable_if_t< !is_same<_Tp, any>::value && !__is_inplace_type<_ValueType>::value &&
+      class _Tp        = decay_t<_ValueType>,
-                                      is_copy_constructible<_Tp>::value> >
+      enable_if_t<_And<_Not<is_same<_Tp, any>>, _Not<__is_inplace_type<_ValueType>>, is_copy_constructible<_Tp>>::value,
-  _LIBCPP_HIDE_FROM_ABI any(_ValueType&& __value);
+                  int> = 0>
+  _LIBCPP_HIDE_FROM_ABI any(_ValueType&& __value) : __h_(nullptr) {
+    __any_imp::_Handler<_Tp>::__create(*this, std::forward<_ValueType>(__value));
+  }
   template <class _ValueType,
             class... _Args,
-            class _Tp = decay_t<_ValueType>,
+            class _Tp                                                                           = decay_t<_ValueType>,
-            class     = enable_if_t< is_constructible<_Tp, _Args...>::value && is_copy_constructible<_Tp>::value > >
+            enable_if_t<is_constructible_v<_Tp, _Args...> && is_copy_constructible_v<_Tp>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, _Args&&... __args);
+  _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, _Args&&... __args) {
+    __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
+  }
-  template <class _ValueType,
+  template <
-            class _Up,
+      class _ValueType,
-            class... _Args,
+      class _Up,
-            class _Tp = decay_t<_ValueType>,
+      class... _Args,
-            class     = enable_if_t< is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
+      class _Tp = decay_t<_ValueType>,
-                                     is_copy_constructible<_Tp>::value> >
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...> && is_copy_constructible_v<_Tp>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, initializer_list<_Up>, _Args&&... __args);
+  _LIBCPP_HIDE_FROM_ABI explicit any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) {
+    __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
+  }
   _LIBCPP_HIDE_FROM_ABI ~any() { this->reset(); }
 @@ -232,43 +238,65 @@ public:
     return *this;
   }
-  _LIBCPP_HIDE_FROM_ABI any& operator=(any&& __rhs) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI any& operator=(any&& __rhs) noexcept {
     any(std::move(__rhs)).swap(*this);
     return *this;
   }
-  template < class _ValueType,
-             class _Tp = decay_t<_ValueType>,
-             class     = enable_if_t< !is_same<_Tp, any>::value && is_copy_constructible<_Tp>::value> >
-  _LIBCPP_HIDE_FROM_ABI any& operator=(_ValueType&& __rhs);
   template <class _ValueType,
-            class... _Args,
+            class _Tp                                                              = decay_t<_ValueType>,
-            class _Tp = decay_t<_ValueType>,
+            enable_if_t<!is_same_v<_Tp, any> && is_copy_constructible_v<_Tp>, int> = 0>
-            class     = enable_if_t< is_constructible<_Tp, _Args...>::value && is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI any& operator=(_ValueType&& __rhs) {
-  _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&...);
+    any(std::forward<_ValueType>(__rhs)).swap(*this);
+    return *this;
+  }
   template <class _ValueType,
-            class _Up,
             class... _Args,
-            class _Tp = decay_t<_ValueType>,
+            class _Tp                                                                           = decay_t<_ValueType>,
-            class     = enable_if_t< is_constructible<_Tp, initializer_list<_Up>&, _Args...>::value &&
+            enable_if_t<is_constructible_v<_Tp, _Args...> && is_copy_constructible_v<_Tp>, int> = 0>
-                                     is_copy_constructible<_Tp>::value> >
+  _LIBCPP_HIDE_FROM_ABI _Tp& emplace(_Args&&... __args) {
-  _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up>, _Args&&...);
+    reset();
+    return __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
+  }
+  template <
+      class _ValueType,
+      class _Up,
+      class... _Args,
+      class _Tp = decay_t<_ValueType>,
+      enable_if_t<is_constructible_v<_Tp, initializer_list<_Up>&, _Args...> && is_copy_constructible_v<_Tp>, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
+    reset();
+    return __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
+  }
   // 6.3.3 any modifiers
-  _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI void reset() noexcept {
     if (__h_)
       this->__call(_Action::_Destroy);
   }
-  _LIBCPP_HIDE_FROM_ABI void swap(any& __rhs) _NOEXCEPT;
+  _LIBCPP_HIDE_FROM_ABI void swap(any& __rhs) noexcept {
+    if (this == &__rhs)
+      return;
+    if (__h_ && __rhs.__h_) {
+      any __tmp;
+      __rhs.__call(_Action::_Move, &__tmp);
+      this->__call(_Action::_Move, &__rhs);
+      __tmp.__call(_Action::_Move, this);
+    } else if (__h_) {
+      this->__call(_Action::_Move, &__rhs);
+    } else if (__rhs.__h_) {
+      __rhs.__call(_Action::_Move, this);
+    }
+  }
   // 6.3.4 any observers
-  _LIBCPP_HIDE_FROM_ABI bool has_value() const _NOEXCEPT { return __h_ != nullptr; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool has_value() const noexcept { return __h_ != nullptr; }
 #    if _LIBCPP_HAS_RTTI
-  _LIBCPP_HIDE_FROM_ABI const type_info& type() const _NOEXCEPT {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const type_info& type() const noexcept {
     if (__h_) {
       return *static_cast<type_info const*>(this->__call(_Action::_TypeInfo));
     } else {
 @@ -285,7 +313,7 @@ private:
   union _Storage {
     _LIBCPP_HIDE_FROM_ABI constexpr _Storage() : __ptr(nullptr) {}
     void* __ptr;
-    __any_imp::_Buffer __buf;
+    alignas(__any_imp::__small_buffer_alignment) char __buf[__any_imp::__small_buffer_size];
   };
   _LIBCPP_HIDE_FROM_ABI void*
 @@ -305,10 +333,10 @@ private:
   friend struct __any_imp::_LargeHandler;
   template <class _ValueType>
-  friend add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) _NOEXCEPT;
+  friend add_pointer_t<add_const_t<_ValueType>> any_cast(any const*) noexcept;
   template <class _ValueType>
-  friend add_pointer_t<_ValueType> any_cast(any*) _NOEXCEPT;
+  friend add_pointer_t<_ValueType> any_cast(any*) noexcept;
   _HandleFuncPtr __h_ = nullptr;
   _Storage __s_;
 @@ -339,22 +367,14 @@ struct _SmallHandler {
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI static _Tp& __create(any& __dest, _Args&&... __args) {
-    typedef allocator<_Tp> _Alloc;
+    auto __ret  = std::__construct_at(reinterpret_cast<_Tp*>(&__dest.__s_.__buf), std::forward<_Args>(__args)...);
-    typedef allocator_traits<_Alloc> _ATraits;
-    _Alloc __a;
-    _Tp* __ret = static_cast<_Tp*>(static_cast<void*>(&__dest.__s_.__buf));
-    _ATraits::construct(__a, __ret, std::forward<_Args>(__args)...);
     __dest.__h_ = &_SmallHandler::__handle;
     return *__ret;
   }
 private:
   _LIBCPP_HIDE_FROM_ABI static void __destroy(any& __this) {
-    typedef allocator<_Tp> _Alloc;
+    std::__destroy_at(reinterpret_cast<_Tp*>(&__this.__s_.__buf));
-    typedef allocator_traits<_Alloc> _ATraits;
-    _Alloc __a;
-    _Tp* __p = static_cast<_Tp*>(static_cast<void*>(&__this.__s_.__buf));
-    _ATraits::destroy(__a, __p);
     __this.__h_ = nullptr;
   }
 @@ -406,26 +426,20 @@ struct _LargeHandler {
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI static _Tp& __create(any& __dest, _Args&&... __args) {
-    typedef allocator<_Tp> _Alloc;
+    _Tp* __ptr = static_cast<_Tp*>(std::__libcpp_allocate<_Tp>(__element_count(1)));
-    typedef allocator_traits<_Alloc> _ATraits;
+    std::__exception_guard __guard([&] { std::__libcpp_deallocate<_Tp>(__ptr, __element_count(1)); });
-    typedef __allocator_destructor<_Alloc> _Dp;
+    std::__construct_at(__ptr, std::forward<_Args>(__args)...);
-    _Alloc __a;
+    __guard.__complete();
-    unique_ptr<_Tp, _Dp> __hold(_ATraits::allocate(__a, 1), _Dp(__a, 1));
+    __dest.__s_.__ptr = __ptr;
-    _Tp* __ret = __hold.get();
-    _ATraits::construct(__a, __ret, std::forward<_Args>(__args)...);
-    __dest.__s_.__ptr = __hold.release();
     __dest.__h_       = &_LargeHandler::__handle;
-    return *__ret;
+    return *__ptr;
   }
 private:
   _LIBCPP_HIDE_FROM_ABI static void __destroy(any& __this) {
-    typedef allocator<_Tp> _Alloc;
-    typedef allocator_traits<_Alloc> _ATraits;
-    _Alloc __a;
     _Tp* __p = static_cast<_Tp*>(__this.__s_.__ptr);
-    _ATraits::destroy(__a, __p);
+    std::__destroy_at(__p);
-    _ATraits::deallocate(__a, __p, 1);
+    std::__libcpp_deallocate<_Tp>(__p, __element_count(1));
     __this.__h_ = nullptr;
   }
 @@ -456,72 +470,24 @@ private:
 } // namespace __any_imp
-template <class _ValueType, class _Tp, class>
-any::any(_ValueType&& __v) : __h_(nullptr) {
-  __any_imp::_Handler<_Tp>::__create(*this, std::forward<_ValueType>(__v));
-}
-template <class _ValueType, class... _Args, class _Tp, class>
-any::any(in_place_type_t<_ValueType>, _Args&&... __args) {
-  __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
-}
-template <class _ValueType, class _Up, class... _Args, class _Tp, class>
-any::any(in_place_type_t<_ValueType>, initializer_list<_Up> __il, _Args&&... __args) {
-  __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
-}
-template <class _ValueType, class, class>
-inline _LIBCPP_HIDE_FROM_ABI any& any::operator=(_ValueType&& __v) {
-  any(std::forward<_ValueType>(__v)).swap(*this);
-  return *this;
-}
-template <class _ValueType, class... _Args, class _Tp, class>
-inline _LIBCPP_HIDE_FROM_ABI _Tp& any::emplace(_Args&&... __args) {
-  reset();
-  return __any_imp::_Handler<_Tp>::__create(*this, std::forward<_Args>(__args)...);
-}
-template <class _ValueType, class _Up, class... _Args, class _Tp, class>
-inline _LIBCPP_HIDE_FROM_ABI _Tp& any::emplace(initializer_list<_Up> __il, _Args&&... __args) {
-  reset();
-  return __any_imp::_Handler<_Tp>::__create(*this, __il, std::forward<_Args>(__args)...);
-}
-inline _LIBCPP_HIDE_FROM_ABI void any::swap(any& __rhs) _NOEXCEPT {
-  if (this == &__rhs)
-    return;
-  if (__h_ && __rhs.__h_) {
-    any __tmp;
-    __rhs.__call(_Action::_Move, &__tmp);
-    this->__call(_Action::_Move, &__rhs);
-    __tmp.__call(_Action::_Move, this);
-  } else if (__h_) {
-    this->__call(_Action::_Move, &__rhs);
-  } else if (__rhs.__h_) {
-    __rhs.__call(_Action::_Move, this);
-  }
-}
 // 6.4 Non-member functions
-inline _LIBCPP_HIDE_FROM_ABI void swap(any& __lhs, any& __rhs) _NOEXCEPT { __lhs.swap(__rhs); }
+inline _LIBCPP_HIDE_FROM_ABI void swap(any& __lhs, any& __rhs) noexcept { __lhs.swap(__rhs); }
 template <class _Tp, class... _Args>
-inline _LIBCPP_HIDE_FROM_ABI any make_any(_Args&&... __args) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI any make_any(_Args&&... __args) {
   return any(in_place_type<_Tp>, std::forward<_Args>(__args)...);
 }
 template <class _Tp, class _Up, class... _Args>
-inline _LIBCPP_HIDE_FROM_ABI any make_any(initializer_list<_Up> __il, _Args&&... __args) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI any make_any(initializer_list<_Up> __il, _Args&&... __args) {
   return any(in_place_type<_Tp>, __il, std::forward<_Args>(__args)...);
 }
 template <class _ValueType>
-inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any const& __v) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any const& __v) {
   using _RawValueType = __remove_cvref_t<_ValueType>;
-  static_assert(is_constructible<_ValueType, _RawValueType const&>::value,
+  static_assert(is_constructible_v<_ValueType, _RawValueType const&>,
                 "ValueType is required to be a const lvalue reference "
                 "or a CopyConstructible type");
   auto __tmp = std::any_cast<add_const_t<_RawValueType>>(&__v);
 @@ -531,9 +497,9 @@ inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any const& __v) {
 }
 template <class _ValueType>
-inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any& __v) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any& __v) {
   using _RawValueType = __remove_cvref_t<_ValueType>;
-  static_assert(is_constructible<_ValueType, _RawValueType&>::value,
+  static_assert(is_constructible_v<_ValueType, _RawValueType&>,
                 "ValueType is required to be an lvalue reference "
                 "or a CopyConstructible type");
   auto __tmp = std::any_cast<_RawValueType>(&__v);
 @@ -543,9 +509,9 @@ inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any& __v) {
 }
 template <class _ValueType>
-inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any&& __v) {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any&& __v) {
   using _RawValueType = __remove_cvref_t<_ValueType>;
-  static_assert(is_constructible<_ValueType, _RawValueType>::value,
+  static_assert(is_constructible_v<_ValueType, _RawValueType>,
                 "ValueType is required to be an rvalue reference "
                 "or a CopyConstructible type");
   auto __tmp = std::any_cast<_RawValueType>(&__v);
 @@ -555,39 +521,31 @@ inline _LIBCPP_HIDE_FROM_ABI _ValueType any_cast(any&& __v) {
 }
 template <class _ValueType>
-inline _LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const* __any) _NOEXCEPT {
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI add_pointer_t<add_const_t<_ValueType>> any_cast(any const* __any) noexcept {
   static_assert(!is_void_v<_ValueType>, "_ValueType may not be void.");
-  static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference.");
+  static_assert(!is_reference_v<_ValueType>, "_ValueType may not be a reference.");
   return std::any_cast<_ValueType>(const_cast<any*>(__any));
 }
-template <class _RetType>
-inline _LIBCPP_HIDE_FROM_ABI _RetType __pointer_or_func_cast(void* __p, /*IsFunction*/ false_type) noexcept {
-  return static_cast<_RetType>(__p);
-}
-template <class _RetType>
-inline _LIBCPP_HIDE_FROM_ABI _RetType __pointer_or_func_cast(void*, /*IsFunction*/ true_type) noexcept {
-  return nullptr;
-}
 template <class _ValueType>
-_LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any* __any) _NOEXCEPT {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI add_pointer_t<_ValueType> any_cast(any* __any) noexcept {
   using __any_imp::_Action;
   static_assert(!is_void_v<_ValueType>, "_ValueType may not be void.");
-  static_assert(!is_reference<_ValueType>::value, "_ValueType may not be a reference.");
+  static_assert(!is_reference_v<_ValueType>, "_ValueType may not be a reference.");
-  typedef add_pointer_t<_ValueType> _ReturnType;
+  if constexpr (!is_function_v<_ValueType>) {
-  if (__any && __any->__h_) {
+    using _ReturnType = add_pointer_t<_ValueType>;
-    void* __p = __any->__call(
+    if (__any && __any->__h_) {
-        _Action::_Get,
+      void* __p = __any->__call(
-        nullptr,
+          _Action::_Get,
+          nullptr,
 #    if _LIBCPP_HAS_RTTI
-        &typeid(_ValueType),
+          &typeid(_ValueType),
 #    else
-        nullptr,
+          nullptr,
 #    endif
-        __any_imp::__get_fallback_typeid<_ValueType>());
+          __any_imp::__get_fallback_typeid<_ValueType>());
-    return std::__pointer_or_func_cast<_ReturnType>(__p, is_function<_ValueType>{});
+      return static_cast<_ReturnType>(__p);
+    }
   }
   return nullptr;
 }
 @@ -613,6 +571,11 @@ _LIBCPP_POP_MACROS
 #    include <type_traits>
 #    include <variant>
 #  endif
+#  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 23
+#    include <cstring>
+#    include <limits>
+#  endif
 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
 #endif // _LIBCPP_ANY

lib/libcxx/include/array+88-56

 @@ -134,7 +134,6 @@ template <size_t I, class T, size_t N> const T&& get(const array<T, N>&&) noexce
 #  include <__type_traits/is_const.h>
 #  include <__type_traits/is_constructible.h>
 #  include <__type_traits/is_nothrow_constructible.h>
-#  include <__type_traits/is_replaceable.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_swappable.h>
 #  include <__type_traits/is_trivially_relocatable.h>
 @@ -176,7 +175,6 @@ template <class _Tp, size_t _Size>
 struct array {
   using __trivially_relocatable _LIBCPP_NODEBUG =
       __conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, array, void>;
-  using __replaceable _LIBCPP_NODEBUG = __conditional_t<__is_replaceable_v<_Tp>, array, void>;
   // types:
   using __self _LIBCPP_NODEBUG = array;
 @@ -212,28 +210,28 @@ struct array {
   }
   // iterators:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator begin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator begin() _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<_Size>(data(), data());
 #  else
     return iterator(data());
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator begin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator begin() const _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<_Size>(data(), data());
 #  else
     return const_iterator(data());
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator end() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator end() _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<_Size>(data() + _Size, data());
 #  else
     return iterator(data() + _Size);
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator end() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator end() const _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<_Size>(data() + _Size, data());
 #  else
 @@ -241,62 +239,81 @@ struct array {
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rbegin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rbegin() _NOEXCEPT {
     return reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator
+  rbegin() const _NOEXCEPT {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rend() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rend() _NOEXCEPT {
     return reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rend() const _NOEXCEPT {
     return const_reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cbegin() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cend() const _NOEXCEPT { return end(); }
+    return begin();
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crbegin() const _NOEXCEPT {
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cend() const _NOEXCEPT {
+    return end();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator
+  crbegin() const _NOEXCEPT {
     return rbegin();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crend() const _NOEXCEPT {
+    return rend();
+  }
   // capacity:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT { return _Size; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT { return _Size; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT { return _Size; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT { return _Size; }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return _Size == 0; }
   // element access:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](size_type __n) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](size_type __n) _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < _Size, "out-of-bounds access in std::array<T, N>");
     return __elems_[__n];
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference operator[](size_type __n) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference
+  operator[](size_type __n) const _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__n < _Size, "out-of-bounds access in std::array<T, N>");
     return __elems_[__n];
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type __n) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type __n) {
     if (__n >= _Size)
       std::__throw_out_of_range("array::at");
     return __elems_[__n];
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type __n) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type __n) const {
     if (__n >= _Size)
       std::__throw_out_of_range("array::at");
     return __elems_[__n];
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front() _NOEXCEPT { return (*this)[0]; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT { return (*this)[0]; }
+    return (*this)[0];
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back() _NOEXCEPT { return (*this)[_Size - 1]; }
+  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT {
+    return (*this)[0];
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back() _NOEXCEPT {
+    return (*this)[_Size - 1];
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const _NOEXCEPT {
     return (*this)[_Size - 1];
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 value_type* data() _NOEXCEPT { return __elems_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 value_type* data() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const value_type* data() const _NOEXCEPT { return __elems_; }
+    return __elems_;
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const value_type* data() const _NOEXCEPT {
+    return __elems_;
+  }
 };
 template <class _Tp>
 @@ -330,8 +347,10 @@ struct array<_Tp, 0> {
   };
   _ALIGNAS_TYPE(_ArrayInStructT) _EmptyType __elems_[sizeof(_ArrayInStructT)];
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 value_type* data() _NOEXCEPT { return nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 value_type* data() _NOEXCEPT { return nullptr; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const value_type* data() const _NOEXCEPT { return nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const value_type* data() const _NOEXCEPT {
+    return nullptr;
+  }
   // No explicit construct/copy/destroy for aggregate type
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void fill(const value_type&) {
 @@ -343,28 +362,28 @@ struct array<_Tp, 0> {
   }
   // iterators:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator begin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator begin() _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<0>(data(), data());
 #  else
     return iterator(data());
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator begin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator begin() const _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<0>(data(), data());
 #  else
     return const_iterator(data());
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator end() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 iterator end() _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<0>(data(), data());
 #  else
     return iterator(data());
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator end() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator end() const _NOEXCEPT {
 #  if defined(_LIBCPP_ABI_BOUNDED_ITERATORS_IN_STD_ARRAY)
     return std::__make_static_bounded_iter<0>(data(), data());
 #  else
 @@ -372,68 +391,77 @@ struct array<_Tp, 0> {
 #  endif
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rbegin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rbegin() _NOEXCEPT {
     return reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator
+  rbegin() const _NOEXCEPT {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rend() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reverse_iterator rend() _NOEXCEPT {
     return reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator rend() const _NOEXCEPT {
     return const_reverse_iterator(begin());
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cbegin() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cend() const _NOEXCEPT { return end(); }
+    return begin();
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crbegin() const _NOEXCEPT {
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_iterator cend() const _NOEXCEPT {
+    return end();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator
+  crbegin() const _NOEXCEPT {
     return rbegin();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 const_reverse_iterator crend() const _NOEXCEPT {
+    return rend();
+  }
   // capacity:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT { return 0; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type size() const _NOEXCEPT { return 0; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT { return 0; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_type max_size() const _NOEXCEPT { return 0; }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return true; }
   // element access:
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](size_type) _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference operator[](size_type) _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference operator[](size_type) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference
+  operator[](size_type) const _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::operator[] on a zero-sized array");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference at(size_type) {
     std::__throw_out_of_range("array<T, 0>::at");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference at(size_type) const {
     std::__throw_out_of_range("array<T, 0>::at");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference front() _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::front() on a zero-sized array");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference front() const _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::front() on a zero-sized array");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX17 reference back() _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::back() on a zero-sized array");
     __libcpp_unreachable();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const_reference back() const _NOEXCEPT {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(false, "cannot call array<T, 0>::back() on a zero-sized array");
     __libcpp_unreachable();
   }
 @@ -503,25 +531,29 @@ struct tuple_element<_Ip, array<_Tp, _Size> > {
 };
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp& get(array<_Tp, _Size>& __a) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp&
+get(array<_Tp, _Size>& __a) _NOEXCEPT {
   static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array)");
   return __a.__elems_[_Ip];
 }
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp& get(const array<_Tp, _Size>& __a) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&
+get(const array<_Tp, _Size>& __a) _NOEXCEPT {
   static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array)");
   return __a.__elems_[_Ip];
 }
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp&& get(array<_Tp, _Size>&& __a) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp&&
+get(array<_Tp, _Size>&& __a) _NOEXCEPT {
   static_assert(_Ip < _Size, "Index out of bounds in std::get<> (std::array &&)");
   return std::move(__a.__elems_[_Ip]);
 }
 template <size_t _Ip, class _Tp, size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&& get(const array<_Tp, _Size>&& __a) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Tp&&
+get(const array<_Tp, _Size>&& __a) _NOEXCEPT {
   static_assert(_Ip < _Size, "Index out of bounds in std::get<> (const std::array &&)");
   return std::move(__a.__elems_[_Ip]);
 }
 @@ -541,7 +573,7 @@ __to_array_rvalue_impl(_Tp (&&__arr)[_Size], index_sequence<_Index...>) {
 }
 template <typename _Tp, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
 to_array(_Tp (&__arr)[_Size]) noexcept(is_nothrow_constructible_v<_Tp, _Tp&>) {
   static_assert(!is_array_v<_Tp>, "[array.creation]/1: to_array does not accept multidimensional arrays.");
   static_assert(is_constructible_v<_Tp, _Tp&>, "[array.creation]/1: to_array requires copy constructible elements.");
 @@ -549,7 +581,7 @@ to_array(_Tp (&__arr)[_Size]) noexcept(is_nothrow_constructible_v<_Tp, _Tp&>) {
 }
 template <typename _Tp, size_t _Size>
-_LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr array<remove_cv_t<_Tp>, _Size>
 to_array(_Tp (&&__arr)[_Size]) noexcept(is_nothrow_move_constructible_v<_Tp>) {
   static_assert(!is_array_v<_Tp>, "[array.creation]/4: to_array does not accept multidimensional arrays.");
   static_assert(is_move_constructible_v<_Tp>, "[array.creation]/4: to_array requires move constructible elements.");

lib/libcxx/include/atomic+2

...	@@ -608,6 +608,8 @@ template <class T>	...	@@ -608,6 +608,8 @@ template <class T>
608	# include <__atomic/atomic_init.h>	608	# include <__atomic/atomic_init.h>
609	# include <__atomic/atomic_lock_free.h>	609	# include <__atomic/atomic_lock_free.h>
610	# include <__atomic/atomic_sync.h>	610	# include <__atomic/atomic_sync.h>
		611	# include <__atomic/atomic_sync_timed.h>
		612	# include <__atomic/atomic_waitable_traits.h>
611	# include <__atomic/check_memory_order.h>	613	# include <__atomic/check_memory_order.h>
612	# include <__atomic/contention_t.h>	614	# include <__atomic/contention_t.h>
613	# include <__atomic/fence.h>	615	# include <__atomic/fence.h>

lib/libcxx/include/barrier+20-24

 @@ -57,8 +57,6 @@ namespace std
 #    include <__atomic/memory_order.h>
 #    include <__cstddef/ptrdiff_t.h>
 #    include <__memory/unique_ptr.h>
-#    include <__thread/poll_with_backoff.h>
-#    include <__thread/timed_backoff_policy.h>
 #    include <__utility/move.h>
 #    include <cstdint>
 #    include <limits>
 @@ -97,19 +95,20 @@ using __barrier_phase_t _LIBCPP_NODEBUG = uint8_t;
 class __barrier_algorithm_base;
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI __barrier_algorithm_base*
+[[__gnu__::__returns_nonnull__, __gnu__::__malloc__]]
-__construct_barrier_algorithm_base(ptrdiff_t& __expected);
+_LIBCPP_EXPORTED_FROM_ABI __barrier_algorithm_base* __construct_barrier_algorithm_base(ptrdiff_t& __expected);
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI bool
+_LIBCPP_EXPORTED_FROM_ABI bool
-__arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier, __barrier_phase_t __old_phase) noexcept;
+__arrive_barrier_algorithm_base([[__gnu__::__nonnull__]] _LIBCPP_NOESCAPE __barrier_algorithm_base* __barrier,
+                                __barrier_phase_t __old_phase) noexcept;
-_LIBCPP_AVAILABILITY_SYNC _LIBCPP_EXPORTED_FROM_ABI void
+_LIBCPP_EXPORTED_FROM_ABI void __destroy_barrier_algorithm_base(
-__destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier) noexcept;
+    [[__gnu__::__nonnull__]] _LIBCPP_NOESCAPE __barrier_algorithm_base* __barrier) noexcept;
 template <class _CompletionF>
 class __barrier_base {
   ptrdiff_t __expected_;
-  unique_ptr<__barrier_algorithm_base, void (*)(__barrier_algorithm_base*)> __base_;
+  unique_ptr<__barrier_algorithm_base, void (*)(_LIBCPP_NOESCAPE __barrier_algorithm_base*)> __base_;
   atomic<ptrdiff_t> __expected_adjustment_;
   _CompletionF __completion_;
   atomic<__barrier_phase_t> __phase_;
 @@ -119,14 +118,13 @@ public:
   static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return numeric_limits<ptrdiff_t>::max(); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_HIDE_FROM_ABI __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
-  __barrier_base(ptrdiff_t __expected, _CompletionF __completion = _CompletionF())
       : __expected_(__expected),
         __base_(std::__construct_barrier_algorithm_base(this->__expected_), &__destroy_barrier_algorithm_base),
         __expected_adjustment_(0),
         __completion_(std::move(__completion)),
         __phase_(0) {}
-  [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t __update) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t __update) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
         __update <= __expected_, "update is greater than the expected count for the current barrier phase");
 @@ -141,11 +139,10 @@ public:
       }
     return __old_phase;
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __old_phase) const {
+  _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __old_phase) const {
-    auto const __test_fn = [this, __old_phase]() -> bool { return __phase_.load(memory_order_acquire) != __old_phase; };
+    __phase_.wait(__old_phase, std::memory_order_acquire);
-    std::__libcpp_thread_poll_with_backoff(__test_fn, __libcpp_timed_backoff_policy());
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() {
+  _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() {
     __expected_adjustment_.fetch_sub(1, memory_order_relaxed);
     (void)arrive(1);
   }
 @@ -158,9 +155,10 @@ class barrier {
 public:
   using arrival_token = typename __barrier_base<_CompletionF>::arrival_token;
-  static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return __barrier_base<_CompletionF>::max(); }
+  [[nodiscard]] static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept {
+    return __barrier_base<_CompletionF>::max();
+  }
-  _LIBCPP_AVAILABILITY_SYNC
   _LIBCPP_HIDE_FROM_ABI explicit barrier(ptrdiff_t __count, _CompletionF __completion = _CompletionF())
       : __b_(__count, std::move(__completion)) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
 @@ -175,15 +173,13 @@ public:
   barrier(barrier const&)            = delete;
   barrier& operator=(barrier const&) = delete;
-  [[nodiscard]] _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t __update = 1) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI arrival_token arrive(ptrdiff_t __update = 1) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update > 0, "barrier:arrive must be called with a value greater than 0");
     return __b_.arrive(__update);
   }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __phase) const {
+  _LIBCPP_HIDE_FROM_ABI void wait(arrival_token&& __phase) const { __b_.wait(std::move(__phase)); }
-    __b_.wait(std::move(__phase));
+  _LIBCPP_HIDE_FROM_ABI void arrive_and_wait() { wait(arrive()); }
-  }
+  _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() { __b_.arrive_and_drop(); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_wait() { wait(arrive()); }
-  _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_drop() { __b_.arrive_and_drop(); }
 };
 _LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/bitset+49-30

 @@ -147,7 +147,6 @@ template <size_t N> struct hash<std::bitset<N>>;
 #  include <__functional/hash.h>
 #  include <__functional/identity.h>
 #  include <__functional/unary_function.h>
-#  include <__tuple/tuple_indices.h>
 #  include <__type_traits/enable_if.h>
 #  include <__type_traits/integral_constant.h>
 #  include <__type_traits/is_char_like_type.h>
 @@ -314,7 +313,7 @@ private:
   _LIBCPP_HIDE_FROM_ABI void __init(unsigned long long __v, true_type) _NOEXCEPT;
 #  else
   template <size_t... _Indices>
-  _LIBCPP_HIDE_FROM_ABI constexpr __bitset(unsigned long long __v, std::__tuple_indices<_Indices...>) _NOEXCEPT
+  _LIBCPP_HIDE_FROM_ABI constexpr __bitset(unsigned long long __v, __index_sequence<_Indices...>) _NOEXCEPT
       : __first_{static_cast<__storage_type>(__v >> (_Indices * __bits_per_word))...} {}
 #  endif // _LIBCPP_CXX03_LANG
 };
 @@ -352,10 +351,9 @@ template <size_t _N_words, size_t _Size>
 inline _LIBCPP_CONSTEXPR __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 #  ifndef _LIBCPP_CXX03_LANG
     : __bitset(__v,
-               std::__make_indices_imp< (_N_words < (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1)
+               __make_index_sequence<(_N_words < (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1)
-                                            ? _N_words
+                                         ? _N_words
-                                            : (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1,
+                                         : (sizeof(unsigned long long) - 1) / sizeof(__storage_type) + 1>())
-                                        0>{})
 #  endif
 {
 #  ifdef _LIBCPP_CXX03_LANG
 @@ -677,53 +675,63 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& set(size_t __pos, bool __val = true);
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& reset() _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& reset(size_t __pos);
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator~() const _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator~() const _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& flip() _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset& flip(size_t __pos);
   // element access:
-#  ifdef _LIBCPP_ABI_BITSET_VECTOR_BOOL_CONST_SUBSCRIPT_RETURN_BOOL
+  // TODO(LLVM 24): Remove the opt-out
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator[](size_t __p) const {
+#  ifndef _LIBCPP_DEPRECATED_ABI_BITSET_CONST_SUBSCRIPT_RETURN_REF
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool operator[](size_t __p) const {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p < _Size, "bitset::operator[] index out of bounds");
     return __base::__make_ref(__p);
   }
 #  else
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __const_reference operator[](size_t __p) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR __const_reference operator[](size_t __p) const {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p < _Size, "bitset::operator[] index out of bounds");
     return __base::__make_ref(__p);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference operator[](size_t __p) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 reference operator[](size_t __p) {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__p < _Size, "bitset::operator[] index out of bounds");
     return __base::__make_ref(__p);
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const { return __base::to_ulong(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long to_ulong() const {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {
+    return __base::to_ulong();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 unsigned long long to_ullong() const {
     return __base::to_ullong();
   }
   template <class _CharT, class _Traits, class _Allocator>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, _Allocator>
   to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
   template <class _CharT, class _Traits>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, allocator<_CharT> >
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, _Traits, allocator<_CharT> >
   to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
   template <class _CharT>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<_CharT, char_traits<_CharT>, allocator<_CharT> >
   to_string(_CharT __zero = _CharT('0'), _CharT __one = _CharT('1')) const;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<char, char_traits<char>, allocator<char> >
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI
+  _LIBCPP_CONSTEXPR_SINCE_CXX23 basic_string<char, char_traits<char>, allocator<char> >
   to_string(char __zero = '0', char __one = '1') const;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t count() const _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t count() const _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT { return _Size; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR size_t size() const _NOEXCEPT { return _Size; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const bitset& __rhs) const _NOEXCEPT;
 #  if _LIBCPP_STD_VER <= 17
   _LIBCPP_HIDE_FROM_ABI bool operator!=(const bitset& __rhs) const _NOEXCEPT;
 #  endif
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool test(size_t __pos) const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool test(size_t __pos) const;
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT { return __base::all(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool all() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT { return __base::any(); }
+    return __base::all();
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool none() const _NOEXCEPT { return !any(); }
+  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator<<(size_t __pos) const _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool any() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator>>(size_t __pos) const _NOEXCEPT;
+    return __base::any();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool none() const _NOEXCEPT { return !any(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator<<(size_t __pos) const _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset operator>>(size_t __pos) const _NOEXCEPT;
 private:
   template <class _CharT, class _Traits>
 @@ -869,7 +877,16 @@ bitset<_Size>::to_string(char __zero, char __one) const {
 template <size_t _Size>
 inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 size_t bitset<_Size>::count() const _NOEXCEPT {
-  return static_cast<size_t>(std::count(__base::__make_iter(0), __base::__make_iter(_Size), true));
+#  if defined(_LIBCPP_COMPILER_CLANG_BASED) && !defined(_LIBCPP_CXX03_LANG)
+  if constexpr (_Size == 0) {
+    return 0;
+  } else if constexpr (_Size <= __base::__bits_per_word) {
+    return __builtin_popcountg(static_cast<unsigned _BitInt(_Size)>(__base::__first_));
+  } else
+#  endif
+  {
+    return static_cast<size_t>(std::count(__base::__make_iter(0), __base::__make_iter(_Size), true));
+  }
 }
 template <size_t _Size>
 @@ -912,7 +929,7 @@ bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT {
 }
 template <size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
 operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
   bitset<_Size> __r = __x;
   __r &= __y;
 @@ -920,7 +937,7 @@ operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
 }
 template <size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
 operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
   bitset<_Size> __r = __x;
   __r |= __y;
 @@ -928,7 +945,7 @@ operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
 }
 template <size_t _Size>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bitset<_Size>
 operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
   bitset<_Size> __r = __x;
   __r ^= __y;
 @@ -937,7 +954,9 @@ operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT {
 template <size_t _Size>
 struct hash<bitset<_Size> > : public __unary_function<bitset<_Size>, size_t> {
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT { return __bs.__hash_code(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT {
+    return __bs.__hash_code();
+  }
 };
 template <class _CharT, class _Traits, size_t _Size>

lib/libcxx/include/ccomplex+3-11

...	@@ -26,18 +26,10 @@	...	@@ -26,18 +26,10 @@
26	# pragma GCC system_header	26	# pragma GCC system_header
27	# endif	27	# endif
28		28
29	# if _LIBCPP_STD_VER >= 20	29	# if _LIBCPP_STD_VER >= 17 && !__building_module(std) && _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS
30		30	# warning <ccomplex> is deprecated in C++17 and removed in C++20. Include <complex> instead.
31	using __standard_header_ccomplex
32	_LIBCPP_DEPRECATED_("removed in C++20. Include <complex> instead.") _LIBCPP_NODEBUG = void;
33	using __use_standard_header_ccomplex _LIBCPP_NODEBUG = __standard_header_ccomplex;
34
35	# elif _LIBCPP_STD_VER >= 17
36
37	using __standard_header_ccomplex _LIBCPP_DEPRECATED_("Include <complex> instead.") _LIBCPP_NODEBUG = void;
38	using __use_standard_header_ccomplex _LIBCPP_NODEBUG = __standard_header_ccomplex;
39
40	# endif	31	# endif
		32
41	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	33	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
42		34
43	#endif // _LIBCPP_CCOMPLEX	35	#endif // _LIBCPP_CCOMPLEX

lib/libcxx/include/chrono+47

...	@@ -218,6 +218,9 @@ template <class ToDuration, class Rep, class Period>	...	@@ -218,6 +218,9 @@ template <class ToDuration, class Rep, class Period>
218	template <class ToDuration, class Rep, class Period>	218	template <class ToDuration, class Rep, class Period>
219	constexpr ToDuration round(const duration<Rep, Period>& d); // C++17	219	constexpr ToDuration round(const duration<Rep, Period>& d); // C++17
220		220
		221	template <class T> struct is_clock; // C++20
		222	template <class T> inline constexpr bool is_clock_v = is_clock<T>::value; // C++20
		223
221	// duration I/O	224	// duration I/O
222	template<class charT, class traits, class Rep, class Period> // C++20	225	template<class charT, class traits, class Rep, class Period> // C++20
223	basic_ostream<charT, traits>&	226	basic_ostream<charT, traits>&
...	@@ -1035,6 +1038,49 @@ constexpr chrono::year operator ""y(unsigned lo	...	@@ -1035,6 +1038,49 @@ constexpr chrono::year operator ""y(unsigned lo
1035	} // chrono_literals	1038	} // chrono_literals
1036	} // literals	1039	} // literals
1037		1040
		1041	namespace std {
		1042	template<class T>
		1043	struct hash; // C++26
		1044	template<class Rep, class Period>
		1045	struct hash<chrono::duration<Rep, Period>>; // C++26
		1046	template<class Clock, class Duration>
		1047	struct hash<chrono::time_point<Clock, Duration>>; // C++26
		1048	template<>
		1049	struct hash<chrono::day>; // C++26
		1050	template<>
		1051	struct hash<chrono::month>; // C++26
		1052	template<>
		1053	struct hash<chrono::year>; // C++26
		1054	template<>
		1055	struct hash<chrono::weekday>; // C++26
		1056	template<>
		1057	struct hash<chrono::weekday_indexed>; // C++26
		1058	template<>
		1059	struct hash<chrono::weekday_last>; // C++26
		1060	template<>
		1061	struct hash<chrono::month_day>; // C++26
		1062	template<>
		1063	struct hash<chrono::month_day_last>; // C++26
		1064	template<>
		1065	struct hash<chrono::month_weekday>; // C++26
		1066	template<>
		1067	struct hash<chrono::month_weekday_last>; // C++26
		1068	template<>
		1069	struct hash<chrono::year_month>; // C++26
		1070	template<>
		1071	struct hash<chrono::year_month_day>; // C++26
		1072	template<>
		1073	struct hash<chrono::year_month_day_last>; // C++26
		1074	template<>
		1075	struct hash<chrono::year_month_weekday>; // C++26
		1076	template<>
		1077	struct hash<chrono::year_month_weekday_last>; // C++26
		1078	template<class Duration, class TimeZonePtr>
		1079	struct hash<chrono::zoned_time<Duration, TimeZonePtr>>; // C++26
		1080	template<>
		1081	struct hash<chrono::leap_second>; // C++26
		1082	} // namespace std
		1083
1038	} // std	1084	} // std
1039	*/	1085	*/
1040		1086
...	@@ -1057,6 +1103,7 @@ constexpr chrono::year operator ""y(unsigned lo	...	@@ -1057,6 +1103,7 @@ constexpr chrono::year operator ""y(unsigned lo
1057	# include <__chrono/day.h>	1103	# include <__chrono/day.h>
1058	# include <__chrono/exception.h>	1104	# include <__chrono/exception.h>
1059	# include <__chrono/hh_mm_ss.h>	1105	# include <__chrono/hh_mm_ss.h>
		1106	# include <__chrono/is_clock.h>
1060	# include <__chrono/literals.h>	1107	# include <__chrono/literals.h>
1061	# include <__chrono/local_info.h>	1108	# include <__chrono/local_info.h>
1062	# include <__chrono/month.h>	1109	# include <__chrono/month.h>

lib/libcxx/include/ciso646+3-6

...	@@ -24,13 +24,10 @@	...	@@ -24,13 +24,10 @@
24	# pragma GCC system_header	24	# pragma GCC system_header
25	# endif	25	# endif
26		26
27	# if _LIBCPP_STD_VER >= 20	27	# if _LIBCPP_STD_VER >= 20 && !__building_module(std) && _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS
28		28	# warning <ciso646> is removed in C++20. Include <version> instead.
29	using __standard_header_ciso646
30	_LIBCPP_DEPRECATED_("removed in C++20. Include <version> instead.") _LIBCPP_NODEBUG = void;
31	using __use_standard_header_ciso646 _LIBCPP_NODEBUG = __standard_header_ciso646;
32
33	# endif	29	# endif
		30
34	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	31	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
35		32
36	#endif // _LIBCPP_CISO646	33	#endif // _LIBCPP_CISO646

lib/libcxx/include/complex+77-65

 @@ -319,8 +319,8 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 complex(const complex<_Xp>& __c)
       : __re_(__c.real()), __im_(__c.imag()) {}
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const { return __re_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type real() const { return __re_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const { return __im_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 value_type imag() const { return __im_; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
 @@ -432,8 +432,8 @@ public:
   _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
   _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float real() const { return __re_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float real() const { return __re_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float imag() const { return __im_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR float imag() const { return __im_; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
 @@ -529,8 +529,8 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
   _LIBCPP_HIDE_FROM_ABI explicit _LIBCPP_CONSTEXPR complex(const complex<long double>& __c);
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double real() const { return __re_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double real() const { return __re_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double imag() const { return __im_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR double imag() const { return __im_; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
 @@ -630,8 +630,8 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<float>& __c);
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR complex(const complex<double>& __c);
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double real() const { return __re_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double real() const { return __re_; }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double imag() const { return __im_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR long double imag() const { return __im_; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void real(value_type __re) { __re_ = __re; }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void imag(value_type __im) { __im_ = __im; }
 @@ -732,7 +732,7 @@ inline _LIBCPP_CONSTEXPR complex<long double>::complex(const complex<double>& __
 // 26.3.6 operators:
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) {
   complex<_Tp> __t(__x);
   __t += __y;
 @@ -740,7 +740,7 @@ operator+(const complex<_Tp>& __x, const complex<_Tp>& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator+(const complex<_Tp>& __x, const _Tp& __y) {
   complex<_Tp> __t(__x);
   __t += __y;
 @@ -748,7 +748,7 @@ operator+(const complex<_Tp>& __x, const _Tp& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator+(const _Tp& __x, const complex<_Tp>& __y) {
   complex<_Tp> __t(__y);
   __t += __x;
 @@ -756,7 +756,7 @@ operator+(const _Tp& __x, const complex<_Tp>& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) {
   complex<_Tp> __t(__x);
   __t -= __y;
 @@ -764,7 +764,7 @@ operator-(const complex<_Tp>& __x, const complex<_Tp>& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator-(const complex<_Tp>& __x, const _Tp& __y) {
   complex<_Tp> __t(__x);
   __t -= __y;
 @@ -772,7 +772,7 @@ operator-(const complex<_Tp>& __x, const _Tp& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator-(const _Tp& __x, const complex<_Tp>& __y) {
   complex<_Tp> __t(-__y);
   __t += __x;
 @@ -780,13 +780,13 @@ operator-(const _Tp& __x, const complex<_Tp>& __y) {
 }
 template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator*(const complex<_Tp>& __lhs, const complex<_Tp>& __rhs) {
   return complex<_Tp>(__from_builtin_tag(), __lhs.__builtin() * __rhs.__builtin());
 }
 template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator*(const complex<_Tp>& __z, const complex<_Tp>& __w) {
   _Tp __a = __z.real();
   _Tp __b = __z.imag();
 @@ -797,7 +797,7 @@ operator*(const complex<_Tp>& __z, const complex<_Tp>& __w) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator*(const complex<_Tp>& __x, const _Tp& __y) {
   complex<_Tp> __t(__x);
   __t *= __y;
 @@ -805,7 +805,7 @@ operator*(const complex<_Tp>& __x, const _Tp& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator*(const _Tp& __x, const complex<_Tp>& __y) {
   complex<_Tp> __t(__y);
   __t *= __x;
 @@ -813,13 +813,13 @@ operator*(const _Tp& __x, const complex<_Tp>& __y) {
 }
 template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator/(const complex<_Tp>& __lhs, const complex<_Tp>& __rhs) {
   return complex<_Tp>(__from_builtin_tag(), __lhs.__builtin() / __rhs.__builtin());
 }
 template <class _Tp, __enable_if_t<!is_floating_point<_Tp>::value, int> >
-_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator/(const complex<_Tp>& __z, const complex<_Tp>& __w) {
   _Tp __a = __z.real();
   _Tp __b = __z.imag();
 @@ -831,13 +831,13 @@ operator/(const complex<_Tp>& __z, const complex<_Tp>& __w) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator/(const complex<_Tp>& __x, const _Tp& __y) {
   return complex<_Tp>(__x.real() / __y, __x.imag() / __y);
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
 operator/(const _Tp& __x, const complex<_Tp>& __y) {
   complex<_Tp> __t(__x);
   __t /= __y;
 @@ -845,12 +845,14 @@ operator/(const _Tp& __x, const complex<_Tp>& __y) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator+(const complex<_Tp>& __x) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator+(const complex<_Tp>& __x) {
   return __x;
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> operator-(const complex<_Tp>& __x) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+operator-(const complex<_Tp>& __x) {
   return complex<_Tp>(-__x.real(), -__x.imag());
 }
 @@ -912,12 +914,13 @@ struct __libcpp_complex_overload_traits<_Tp, false, true> {
 // real
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp real(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp real(const complex<_Tp>& __c) {
   return __c.real();
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+typename __libcpp_complex_overload_traits<_Tp>::_ValueType
 real(_Tp __re) {
   return __re;
 }
 @@ -925,12 +928,13 @@ real(_Tp __re) {
 // imag
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp imag(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp imag(const complex<_Tp>& __c) {
   return __c.imag();
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
+typename __libcpp_complex_overload_traits<_Tp>::_ValueType
 imag(_Tp) {
   return 0;
 }
 @@ -938,36 +942,36 @@ imag(_Tp) {
 // abs
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _Tp abs(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Tp abs(const complex<_Tp>& __c) {
   return std::hypot(__c.real(), __c.imag());
 }
 // arg
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _Tp arg(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Tp arg(const complex<_Tp>& __c) {
   return std::atan2(__c.imag(), __c.real());
 }
 template <class _Tp, __enable_if_t<is_same<_Tp, long double>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI long double arg(_Tp __re) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI long double arg(_Tp __re) {
   return std::atan2l(0.L, __re);
 }
 template <class _Tp, __enable_if_t<is_integral<_Tp>::value || is_same<_Tp, double>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI double arg(_Tp __re) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI double arg(_Tp __re) {
   return std::atan2(0., __re);
 }
 template <class _Tp, __enable_if_t<is_same<_Tp, float>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI float arg(_Tp __re) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI float arg(_Tp __re) {
   return std::atan2f(0.F, __re);
 }
 // norm
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp norm(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp norm(const complex<_Tp>& __c) {
   if (std::__constexpr_isinf(__c.real()))
     return std::abs(__c.real());
   if (std::__constexpr_isinf(__c.imag()))
 @@ -976,7 +980,8 @@ inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp norm(const comple
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __libcpp_complex_overload_traits<_Tp>::_ValueType
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+typename __libcpp_complex_overload_traits<_Tp>::_ValueType
 norm(_Tp __re) {
   typedef typename __libcpp_complex_overload_traits<_Tp>::_ValueType _ValueType;
   return static_cast<_ValueType>(__re) * __re;
 @@ -985,12 +990,14 @@ norm(_Tp __re) {
 // conj
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp> conj(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 complex<_Tp>
+conj(const complex<_Tp>& __c) {
   return complex<_Tp>(__c.real(), -__c.imag());
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
+typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
 conj(_Tp __re) {
   typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
   return _ComplexType(__re);
 @@ -999,7 +1006,7 @@ conj(_Tp __re) {
 // proj
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> proj(const complex<_Tp>& __c) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> proj(const complex<_Tp>& __c) {
   complex<_Tp> __r = __c;
   if (std::isinf(__c.real()) || std::isinf(__c.imag()))
     __r = complex<_Tp>(INFINITY, std::copysign(_Tp(0), __c.imag()));
 @@ -1007,14 +1014,16 @@ inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> proj(const complex<_Tp>& __c) {
 }
 template <class _Tp, __enable_if_t<is_floating_point<_Tp>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType proj(_Tp __re) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
+proj(_Tp __re) {
   if (std::isinf(__re))
     __re = std::abs(__re);
   return complex<_Tp>(__re);
 }
 template <class _Tp, __enable_if_t<is_integral<_Tp>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType proj(_Tp __re) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_ComplexType
+proj(_Tp __re) {
   typedef typename __libcpp_complex_overload_traits<_Tp>::_ComplexType _ComplexType;
   return _ComplexType(__re);
 }
 @@ -1022,7 +1031,7 @@ inline _LIBCPP_HIDE_FROM_ABI typename __libcpp_complex_overload_traits<_Tp>::_Co
 // polar
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta = _Tp()) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta = _Tp()) {
   if (std::isnan(__rho) || std::signbit(__rho))
     return complex<_Tp>(_Tp(NAN), _Tp(NAN));
   if (std::isnan(__theta)) {
 @@ -1047,21 +1056,21 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> polar(const _Tp& __rho, const _Tp& __theta =
 // log
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log(const complex<_Tp>& __x) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log(const complex<_Tp>& __x) {
   return complex<_Tp>(std::log(std::abs(__x)), std::arg(__x));
 }
 // log10
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log10(const complex<_Tp>& __x) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> log10(const complex<_Tp>& __x) {
   return std::log(__x) / std::log(_Tp(10));
 }
 // sqrt
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
   if (std::isinf(__x.imag()))
     return complex<_Tp>(_Tp(INFINITY), __x.imag());
   if (std::isinf(__x.real())) {
 @@ -1075,7 +1084,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> sqrt(const complex<_Tp>& __x) {
 // exp
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
   _Tp __i = __x.imag();
   if (__i == 0) {
     return complex<_Tp>(std::exp(__x.real()), std::copysign(_Tp(0), __x.imag()));
 @@ -1097,24 +1106,27 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> exp(const complex<_Tp>& __x) {
 // pow
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> pow(const complex<_Tp>& __x, const complex<_Tp>& __y) {
   return std::exp(__y * std::log(__x));
 }
 template <class _Tp, class _Up, __enable_if_t<is_floating_point<_Tp>::value && is_floating_point<_Up>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> > pow(const complex<_Tp>& __x, const complex<_Up>& __y) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> >
+pow(const complex<_Tp>& __x, const complex<_Up>& __y) {
   typedef complex<__promote_t<_Tp, _Up> > result_type;
   return std::pow(result_type(__x), result_type(__y));
 }
 template <class _Tp, class _Up, __enable_if_t<is_floating_point<_Tp>::value && is_arithmetic<_Up>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> > pow(const complex<_Tp>& __x, const _Up& __y) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> >
+pow(const complex<_Tp>& __x, const _Up& __y) {
   typedef complex<__promote_t<_Tp, _Up> > result_type;
   return std::pow(result_type(__x), result_type(__y));
 }
 template <class _Tp, class _Up, __enable_if_t<is_arithmetic<_Tp>::value && is_floating_point<_Up>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> > pow(const _Tp& __x, const complex<_Up>& __y) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<__promote_t<_Tp, _Up> >
+pow(const _Tp& __x, const complex<_Up>& __y) {
   typedef complex<__promote_t<_Tp, _Up> > result_type;
   return std::pow(result_type(__x), result_type(__y));
 }
 @@ -1129,7 +1141,7 @@ inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> __sqr(const complex<_Tp>& __x) {
 // asinh
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> asinh(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> asinh(const complex<_Tp>& __x) {
   const _Tp __pi(atan2(+0., -0.));
   if (std::isinf(__x.real())) {
     if (std::isnan(__x.imag()))
 @@ -1154,7 +1166,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> asinh(const complex<_Tp>& __x) {
 // acosh
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> acosh(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> acosh(const complex<_Tp>& __x) {
   const _Tp __pi(atan2(+0., -0.));
   if (std::isinf(__x.real())) {
     if (std::isnan(__x.imag()))
 @@ -1183,7 +1195,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> acosh(const complex<_Tp>& __x) {
 // atanh
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
   const _Tp __pi(atan2(+0., -0.));
   if (std::isinf(__x.imag())) {
     return complex<_Tp>(std::copysign(_Tp(0), __x.real()), std::copysign(__pi / _Tp(2), __x.imag()));
 @@ -1209,7 +1221,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> atanh(const complex<_Tp>& __x) {
 // sinh
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> sinh(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> sinh(const complex<_Tp>& __x) {
   if (std::isinf(__x.real()) && !std::isfinite(__x.imag()))
     return complex<_Tp>(__x.real(), _Tp(NAN));
   if (__x.real() == 0 && !std::isfinite(__x.imag()))
 @@ -1222,7 +1234,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> sinh(const complex<_Tp>& __x) {
 // cosh
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
   if (std::isinf(__x.real()) && !std::isfinite(__x.imag()))
     return complex<_Tp>(std::abs(__x.real()), _Tp(NAN));
   if (__x.real() == 0 && !std::isfinite(__x.imag()))
 @@ -1237,7 +1249,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> cosh(const complex<_Tp>& __x) {
 // tanh
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
   if (std::isinf(__x.real())) {
     if (!std::isfinite(__x.imag()))
       return complex<_Tp>(std::copysign(_Tp(1), __x.real()), _Tp(0));
 @@ -1257,7 +1269,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> tanh(const complex<_Tp>& __x) {
 // asin
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
   complex<_Tp> __z = std::asinh(complex<_Tp>(-__x.imag(), __x.real()));
   return complex<_Tp>(__z.imag(), -__z.real());
 }
 @@ -1265,7 +1277,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> asin(const complex<_Tp>& __x) {
 // acos
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
   const _Tp __pi(atan2(+0., -0.));
   if (std::isinf(__x.real())) {
     if (std::isnan(__x.imag()))
 @@ -1297,7 +1309,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> acos(const complex<_Tp>& __x) {
 // atan
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
   complex<_Tp> __z = std::atanh(complex<_Tp>(-__x.imag(), __x.real()));
   return complex<_Tp>(__z.imag(), -__z.real());
 }
 @@ -1305,7 +1317,7 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> atan(const complex<_Tp>& __x) {
 // sin
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
   complex<_Tp> __z = std::sinh(complex<_Tp>(-__x.imag(), __x.real()));
   return complex<_Tp>(__z.imag(), -__z.real());
 }
 @@ -1313,14 +1325,14 @@ _LIBCPP_HIDE_FROM_ABI complex<_Tp> sin(const complex<_Tp>& __x) {
 // cos
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> cos(const complex<_Tp>& __x) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI complex<_Tp> cos(const complex<_Tp>& __x) {
   return std::cosh(complex<_Tp>(-__x.imag(), __x.real()));
 }
 // tan
 template <class _Tp>
-_LIBCPP_HIDE_FROM_ABI complex<_Tp> tan(const complex<_Tp>& __x) {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI complex<_Tp> tan(const complex<_Tp>& __x) {
   complex<_Tp> __z = std::tanh(complex<_Tp>(-__x.imag(), __x.real()));
   return complex<_Tp>(__z.imag(), -__z.real());
 }
 @@ -1398,7 +1410,7 @@ struct tuple_element<_Ip, complex<_Tp>> {
 };
 template <size_t _Ip, class _Xp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>& __z) noexcept {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>& __z) noexcept {
   static_assert(_Ip < 2, "Index value is out of range.");
   if constexpr (_Ip == 0) {
     return __z.__re_;
 @@ -1408,7 +1420,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Xp& get(complex<_Xp>& __z) noexcept {
 }
 template <size_t _Ip, class _Xp>
-_LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&& __z) noexcept {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&& __z) noexcept {
   static_assert(_Ip < 2, "Index value is out of range.");
   if constexpr (_Ip == 0) {
     return std::move(__z.__re_);
 @@ -1418,7 +1430,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr _Xp&& get(complex<_Xp>&& __z) noexcept {
 }
 template <size_t _Ip, class _Xp>
-_LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>& __z) noexcept {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>& __z) noexcept {
   static_assert(_Ip < 2, "Index value is out of range.");
   if constexpr (_Ip == 0) {
     return __z.__re_;
 @@ -1428,7 +1440,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr const _Xp& get(const complex<_Xp>& __z) noexcept
 }
 template <size_t _Ip, class _Xp>
-_LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&& __z) noexcept {
+[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI constexpr const _Xp&& get(const complex<_Xp>&& __z) noexcept {
   static_assert(_Ip < 2, "Index value is out of range.");
   if constexpr (_Ip == 0) {
     return std::move(__z.__re_);

lib/libcxx/include/complex.h+10-10

...	@@ -18,19 +18,19 @@	...	@@ -18,19 +18,19 @@
18	*/	18	*/
19		19
20	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	20	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
21	# include <__cxx03/complex.h>	21	# include <__cxx03/__config>
22	#else	22	#else
23	# include <__config>	23	# include <__config>
		24	#endif
24		25
25	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	26	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
26	# pragma GCC system_header	27	# pragma GCC system_header
27	# endif	28	#endif
28		29
29	# ifdef __cplusplus	30	#ifdef __cplusplus
30	# include <complex>	31	# include <complex>
31	# elif __has_include_next(<complex.h>)	32	#elif __has_include_next(<complex.h>)
32	# include_next <complex.h>	33	# include_next <complex.h>
33	# endif	34	#endif
34	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
35		35
36	#endif // _LIBCPP_COMPLEX_H	36	#endif // _LIBCPP_COMPLEX_H

lib/libcxx/include/condition_variable+3-3

...	@@ -206,14 +206,14 @@ public:	...	@@ -206,14 +206,14 @@ public:
206	# if _LIBCPP_STD_VER >= 20	206	# if _LIBCPP_STD_VER >= 20
207		207
208	template <class _Lock, class _Predicate>	208	template <class _Lock, class _Predicate>
209	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);	209	_LIBCPP_HIDE_FROM_ABI bool wait(_Lock& __lock, stop_token __stoken, _Predicate __pred);
210		210
211	template <class _Lock, class _Clock, class _Duration, class _Predicate>	211	template <class _Lock, class _Clock, class _Duration, class _Predicate>
212	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool wait_until(	212	_LIBCPP_HIDE_FROM_ABI bool wait_until(
213	_Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);	213	_Lock& __lock, stop_token __stoken, const chrono::time_point<_Clock, _Duration>& __abs_time, _Predicate __pred);
214		214
215	template <class _Lock, class _Rep, class _Period, class _Predicate>	215	template <class _Lock, class _Rep, class _Period, class _Predicate>
216	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool	216	_LIBCPP_HIDE_FROM_ABI bool
217	wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);	217	wait_for(_Lock& __lock, stop_token __stoken, const chrono::duration<_Rep, _Period>& __rel_time, _Predicate __pred);
218		218
219	# endif // _LIBCPP_STD_VER >= 20	219	# endif // _LIBCPP_STD_VER >= 20

lib/libcxx/include/cstdalign+3-10

...	@@ -43,17 +43,10 @@ Macros:	...	@@ -43,17 +43,10 @@ Macros:
43	# undef __alignof_is_defined	43	# undef __alignof_is_defined
44	# define __alignof_is_defined 1	44	# define __alignof_is_defined 1
45		45
46	# if _LIBCPP_STD_VER >= 20	46	# if _LIBCPP_STD_VER >= 17 && !__building_module(std) && _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS
47		47	# warning <cstdalign> is deprecated in C++17 and removed in C++20.
48	using __standard_header_cstdalign _LIBCPP_DEPRECATED_("removed in C++20.") _LIBCPP_NODEBUG = void;
49	using __use_standard_header_cstdalign _LIBCPP_NODEBUG = __standard_header_cstdalign;
50
51	# elif _LIBCPP_STD_VER >= 17
52
53	using __standard_header_cstdalign _LIBCPP_DEPRECATED _LIBCPP_NODEBUG = void;
54	using __use_standard_header_cstdalign _LIBCPP_NODEBUG = __standard_header_cstdalign;
55
56	# endif	48	# endif
		49
57	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	50	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
58		51
59	#endif // _LIBCPP_CSTDALIGN	52	#endif // _LIBCPP_CSTDALIGN

lib/libcxx/include/cstdbool+3-10

...	@@ -31,17 +31,10 @@ Macros:	...	@@ -31,17 +31,10 @@ Macros:
31	# undef __bool_true_false_are_defined	31	# undef __bool_true_false_are_defined
32	# define __bool_true_false_are_defined 1	32	# define __bool_true_false_are_defined 1
33		33
34	# if _LIBCPP_STD_VER >= 20	34	# if _LIBCPP_STD_VER >= 17 && !__building_module(std) && _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS
35		35	# warning <cstdbool> is deprecated in C++17 and removed in C++20.
36	using __standard_header_cstdbool _LIBCPP_DEPRECATED_("removed in C++20.") _LIBCPP_NODEBUG = void;
37	using __use_standard_header_cstdbool _LIBCPP_NODEBUG = __standard_header_cstdbool;
38
39	# elif _LIBCPP_STD_VER >= 17
40
41	using __standard_header_cstdbool _LIBCPP_DEPRECATED _LIBCPP_NODEBUG = void;
42	using __use_standard_header_cstdbool _LIBCPP_NODEBUG = __standard_header_cstdbool;
43
44	# endif	36	# endif
		37
45	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	38	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
46		39
47	#endif // _LIBCPP_CSTDBOOL	40	#endif // _LIBCPP_CSTDBOOL

lib/libcxx/include/ctgmath+2-11

...	@@ -28,17 +28,8 @@	...	@@ -28,17 +28,8 @@
28	# pragma GCC system_header	28	# pragma GCC system_header
29	# endif	29	# endif
30		30
31	# if _LIBCPP_STD_VER >= 20	31	# if _LIBCPP_STD_VER >= 17 && !__building_module(std) && _LIBCPP_DIAGNOSE_DEPRECATED_HEADERS
32		32	# warning <ctgmath> is deprecated in C++17 and removed in C++20. Include <cmath> and <complex> instead.
33	using __standard_header_ctgmath
34	_LIBCPP_DEPRECATED_("removed in C++20. Include <cmath> and <complex> instead.") _LIBCPP_NODEBUG = void;
35	using __use_standard_header_ctgmath _LIBCPP_NODEBUG = __standard_header_ctgmath;
36
37	# elif _LIBCPP_STD_VER >= 17
38
39	using __standard_header_ctgmath _LIBCPP_DEPRECATED_("Include <cmath> and <complex> instead.") _LIBCPP_NODEBUG = void;
40	using __use_standard_header_ctgmath _LIBCPP_NODEBUG = __standard_header_ctgmath;
41
42	# endif	33	# endif
43		34
44	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	35	#endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)

lib/libcxx/include/ctype.h+24-24

...	@@ -30,36 +30,36 @@ int toupper(int c);	...	@@ -30,36 +30,36 @@ int toupper(int c);
30	*/	30	*/
31		31
32	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	32	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
33	# include <__cxx03/ctype.h>	33	# include <__cxx03/__config>
34	#else	34	#else
35	# include <__config>	35	# include <__config>
		36	#endif
36		37
37	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	38	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
38	# pragma GCC system_header	39	# pragma GCC system_header
39	# endif	40	#endif
40		41
41	# if __has_include_next(<ctype.h>)	42	#if __has_include_next(<ctype.h>)
42	# include_next <ctype.h>	43	# include_next <ctype.h>
43	# endif	44	#endif
44		45
45	# ifdef __cplusplus	46	#ifdef __cplusplus
46		47
47	# undef isalnum	48	# undef isalnum
48	# undef isalpha	49	# undef isalpha
49	# undef isblank	50	# undef isblank
50	# undef iscntrl	51	# undef iscntrl
51	# undef isdigit	52	# undef isdigit
52	# undef isgraph	53	# undef isgraph
53	# undef islower	54	# undef islower
54	# undef isprint	55	# undef isprint
55	# undef ispunct	56	# undef ispunct
56	# undef isspace	57	# undef isspace
57	# undef isupper	58	# undef isupper
58	# undef isxdigit	59	# undef isxdigit
59	# undef tolower	60	# undef tolower
60	# undef toupper	61	# undef toupper
61		62
62	# endif	63	#endif
63	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
64		64
65	#endif // _LIBCPP_CTYPE_H	65	#endif // _LIBCPP_CTYPE_H

lib/libcxx/include/cwchar+2-2

...	@@ -231,8 +231,8 @@ __constexpr_wmemcmp(const wchar_t* __lhs, const wchar_t* __rhs, size_t __count)	...	@@ -231,8 +231,8 @@ __constexpr_wmemcmp(const wchar_t* __lhs, const wchar_t* __rhs, size_t __count)
231		231
232	template <class _Tp, class _Up>	232	template <class _Tp, class _Up>
233	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __constexpr_wmemchr(_Tp* __str, _Up __value, size_t __count) {	233	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _Tp* __constexpr_wmemchr(_Tp* __str, _Up __value, size_t __count) {
234	static_assert(sizeof(_Tp) == sizeof(wchar_t)&& _LIBCPP_ALIGNOF(_Tp) >= _LIBCPP_ALIGNOF(wchar_t) &&	234	static_assert(sizeof(_Tp) == sizeof(wchar_t) && _LIBCPP_ALIGNOF(_Tp) >= _LIBCPP_ALIGNOF(wchar_t) &&
235	__libcpp_is_trivially_equality_comparable<_Tp, _Tp>::value,	235	__is_trivially_equality_comparable_v<_Tp, _Tp>,
236	"Calling wmemchr on non-trivially equality comparable types is unsafe.");	236	"Calling wmemchr on non-trivially equality comparable types is unsafe.");
237		237
238	# if __has_builtin(__builtin_wmemchr)	238	# if __has_builtin(__builtin_wmemchr)

lib/libcxx/include/deque+109-225

...	@@ -191,9 +191,9 @@ template <class T, class Allocator, class Predicate>	...	@@ -191,9 +191,9 @@ template <class T, class Allocator, class Predicate>
191	# include <__algorithm/min.h>	191	# include <__algorithm/min.h>
192	# include <__algorithm/move.h>	192	# include <__algorithm/move.h>
193	# include <__algorithm/move_backward.h>	193	# include <__algorithm/move_backward.h>
		194	# include <__algorithm/ranges_copy_n.h>
194	# include <__algorithm/remove.h>	195	# include <__algorithm/remove.h>
195	# include <__algorithm/remove_if.h>	196	# include <__algorithm/remove_if.h>
196	# include <__algorithm/unwrap_iter.h>
197	# include <__assert>	197	# include <__assert>
198	# include <__config>	198	# include <__config>
199	# include <__debug_utils/sanitizers.h>	199	# include <__debug_utils/sanitizers.h>
...	@@ -220,21 +220,19 @@ template <class T, class Allocator, class Predicate>	...	@@ -220,21 +220,19 @@ template <class T, class Allocator, class Predicate>
220	# include <__ranges/concepts.h>	220	# include <__ranges/concepts.h>
221	# include <__ranges/container_compatible_range.h>	221	# include <__ranges/container_compatible_range.h>
222	# include <__ranges/from_range.h>	222	# include <__ranges/from_range.h>
223	# include <__ranges/size.h>
224	# include <__split_buffer>	223	# include <__split_buffer>
225	# include <__type_traits/conditional.h>	224	# include <__type_traits/conditional.h>
226	# include <__type_traits/container_traits.h>	225	# include <__type_traits/container_traits.h>
227	# include <__type_traits/disjunction.h>
228	# include <__type_traits/enable_if.h>	226	# include <__type_traits/enable_if.h>
229	# include <__type_traits/is_allocator.h>	227	# include <__type_traits/is_allocator.h>
230	# include <__type_traits/is_convertible.h>	228	# include <__type_traits/is_convertible.h>
231	# include <__type_traits/is_nothrow_assignable.h>	229	# include <__type_traits/is_nothrow_assignable.h>
232	# include <__type_traits/is_nothrow_constructible.h>	230	# include <__type_traits/is_nothrow_constructible.h>
233	# include <__type_traits/is_replaceable.h>
234	# include <__type_traits/is_same.h>	231	# include <__type_traits/is_same.h>
235	# include <__type_traits/is_swappable.h>	232	# include <__type_traits/is_swappable.h>
236	# include <__type_traits/is_trivially_relocatable.h>	233	# include <__type_traits/is_trivially_relocatable.h>
237	# include <__type_traits/type_identity.h>	234	# include <__type_traits/type_identity.h>
		235	# include <__utility/exception_guard.h>
238	# include <__utility/forward.h>	236	# include <__utility/forward.h>
239	# include <__utility/move.h>	237	# include <__utility/move.h>
240	# include <__utility/pair.h>	238	# include <__utility/pair.h>
...	@@ -461,9 +459,8 @@ private:	...	@@ -461,9 +459,8 @@ private:
461	__deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize>;	459	__deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer, _DiffType, _BlockSize>;
462		460
463	public:	461	public:
464	using __is_segmented_iterator _LIBCPP_NODEBUG = true_type;	462	using __segment_iterator _LIBCPP_NODEBUG = _MapPointer;
465	using __segment_iterator _LIBCPP_NODEBUG = _MapPointer;	463	using __local_iterator _LIBCPP_NODEBUG = _Pointer;
466	using __local_iterator _LIBCPP_NODEBUG = _Pointer;
467		464
468	static _LIBCPP_HIDE_FROM_ABI __segment_iterator __segment(_Iterator __iter) { return __iter.__m_iter_; }	465	static _LIBCPP_HIDE_FROM_ABI __segment_iterator __segment(_Iterator __iter) { return __iter.__m_iter_; }
469	static _LIBCPP_HIDE_FROM_ABI __local_iterator __local(_Iterator __iter) { return __iter.__ptr_; }	466	static _LIBCPP_HIDE_FROM_ABI __local_iterator __local(_Iterator __iter) { return __iter.__ptr_; }
...	@@ -488,6 +485,9 @@ const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,	...	@@ -488,6 +485,9 @@ const _DiffType __deque_iterator<_ValueType, _Pointer, _Reference, _MapPointer,
488		485
489	template <class _Tp, class _Allocator /= allocator<_Tp>/>	486	template <class _Tp, class _Allocator /= allocator<_Tp>/>
490	class deque {	487	class deque {
		488	template <class _Up, class _Alloc>
		489	using __split_buffer _LIBCPP_NODEBUG = std::__split_buffer<_Up, _Alloc, __split_buffer_pointer_layout>;
		490
491	public:	491	public:
492	// types:	492	// types:
493		493
...	@@ -531,10 +531,6 @@ public:	...	@@ -531,10 +531,6 @@ public:
531	__libcpp_is_trivially_relocatable<__map>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,	531	__libcpp_is_trivially_relocatable<__map>::value && __libcpp_is_trivially_relocatable<allocator_type>::value,
532	deque,	532	deque,
533	void>;	533	void>;
534	using __replaceable _LIBCPP_NODEBUG =
535	__conditional_t<__is_replaceable_v<__map> && __container_allocator_is_replaceable<__alloc_traits>::value,
536	deque,
537	void>;
538		534
539	static_assert(is_nothrow_default_constructible<allocator_type>::value ==	535	static_assert(is_nothrow_default_constructible<allocator_type>::value ==
540	is_nothrow_default_constructible<__pointer_allocator>::value,	536	is_nothrow_default_constructible<__pointer_allocator>::value,
...	@@ -635,7 +631,7 @@ public:	...	@@ -635,7 +631,7 @@ public:
635	# endif	631	# endif
636	_LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v);	632	_LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v);
637		633
638	template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>	634	template <__enable_if_t<__is_allocator_v<_Allocator>, int> = 0>
639	_LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)	635	_LIBCPP_HIDE_FROM_ABI deque(size_type __n, const value_type& __v, const allocator_type& __a)
640	: __map_(__pointer_allocator(__a)), __start_(0), __size_(0), __alloc_(__a) {	636	: __map_(__pointer_allocator(__a)), __start_(0), __size_(0), __alloc_(__a) {
641	__annotate_new(0);	637	__annotate_new(0);
...	@@ -703,8 +699,16 @@ public:	...	@@ -703,8 +699,16 @@ public:
703	__assign_with_size_random_access(ranges::begin(__range), __n);	699	__assign_with_size_random_access(ranges::begin(__range), __n);
704		700
705	} else if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {	701	} else if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {
706	auto __n = static_cast<size_type>(ranges::distance(__range));	702	auto __n = ranges::distance(__range);
707	__assign_with_size(ranges::begin(__range), __n);	703	auto __first = ranges::begin(__range);
		704
		705	auto __result = std::ranges::copy_n(std::move(__first), std::min<size_t>(__n, size()), begin());
		706
		707	if (static_cast<size_type>(__n) > size()) {
		708	__append_with_size(std::move(__result.in), __n - size());
		709	} else {
		710	__erase_to_end(__result.out);
		711	}
708		712
709	} else {	713	} else {
710	__assign_with_sentinel(ranges::begin(__range), ranges::end(__range));	714	__assign_with_sentinel(ranges::begin(__range), ranges::end(__range));
...	@@ -720,45 +724,53 @@ public:	...	@@ -720,45 +724,53 @@ public:
720		724
721	// iterators:	725	// iterators:
722		726
723	_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {	727	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
724	__map_pointer __mp = __map_.begin() + __start_ / __block_size;	728	__map_pointer __mp = __map_.begin() + __start_ / __block_size;
725	return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);	729	return iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
726	}	730	}
727		731
728	_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {	732	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
729	__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);	733	__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __start_ / __block_size);
730	return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);	734	return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __start_ % __block_size);
731	}	735	}
732		736
733	_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {	737	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {
734	size_type __p = size() + __start_;	738	size_type __p = size() + __start_;
735	__map_pointer __mp = __map_.begin() + __p / __block_size;	739	__map_pointer __mp = __map_.begin() + __p / __block_size;
736	return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);	740	return iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
737	}	741	}
738		742
739	_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {	743	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
740	size_type __p = size() + __start_;	744	size_type __p = size() + __start_;
741	__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);	745	__map_const_pointer __mp = static_cast<__map_const_pointer>(__map_.begin() + __p / __block_size);
742	return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);	746	return const_iterator(__mp, __map_.empty() ? 0 : *__mp + __p % __block_size);
743	}	747	}
744		748
745	_LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }	749	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
746	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }	750	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
747	_LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }	751	return const_reverse_iterator(end());
748	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }	752	}
		753	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
		754	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
		755	return const_reverse_iterator(begin());
		756	}
749		757
750	_LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }	758	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
751	_LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }	759	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
752	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }	760	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {
753	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return const_reverse_iterator(begin()); }	761	return const_reverse_iterator(end());
		762	}
		763	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
		764	return const_reverse_iterator(begin());
		765	}
754		766
755	// capacity:	767	// capacity:
756	_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size(); }	768	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size(); }
757		769
758	_LIBCPP_HIDE_FROM_ABI size_type& __size() _NOEXCEPT { return __size_; }	770	_LIBCPP_HIDE_FROM_ABI size_type& __size() _NOEXCEPT { return __size_; }
759	_LIBCPP_HIDE_FROM_ABI const size_type& __size() const _NOEXCEPT { return __size_; }	771	_LIBCPP_HIDE_FROM_ABI const size_type& __size() const _NOEXCEPT { return __size_; }
760		772
761	_LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {	773	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
762	return std::min<size_type>(__alloc_traits::max_size(__alloc()), numeric_limits<difference_type>::max());	774	return std::min<size_type>(__alloc_traits::max_size(__alloc()), numeric_limits<difference_type>::max());
763	}	775	}
764	_LIBCPP_HIDE_FROM_ABI void resize(size_type __n);	776	_LIBCPP_HIDE_FROM_ABI void resize(size_type __n);
...	@@ -767,18 +779,22 @@ public:	...	@@ -767,18 +779,22 @@ public:
767	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return size() == 0; }	779	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return size() == 0; }
768		780
769	// element access:	781	// element access:
770	_LIBCPP_HIDE_FROM_ABI reference operator[](size_type __i) _NOEXCEPT;	782	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference operator[](size_type __i) _NOEXCEPT;
771	_LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __i) const _NOEXCEPT;	783	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __i) const _NOEXCEPT;
772	_LIBCPP_HIDE_FROM_ABI reference at(size_type __i);	784	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference at(size_type __i);
773	_LIBCPP_HIDE_FROM_ABI const_reference at(size_type __i) const;	785	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __i) const;
774	_LIBCPP_HIDE_FROM_ABI reference front() _NOEXCEPT;	786	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference front() _NOEXCEPT;
775	_LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT;	787	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT;
776	_LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT;	788	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference back() _NOEXCEPT;
777	_LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT;	789	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT;
778		790
779	// 23.2.2.3 modifiers:	791	// 23.2.2.3 modifiers:
780	_LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);	792	_LIBCPP_HIDE_FROM_ABI void push_front(const value_type& __v);
781	_LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __v);	793	_LIBCPP_HIDE_FROM_ABI void push_back(const value_type& __v);
		794
		795	template <class... _Args>
		796	_LIBCPP_HIDE_FROM_ABI iterator __emplace(const_iterator __p, _Args&&... __args);
		797
782	# ifndef _LIBCPP_CXX03_LANG	798	# ifndef _LIBCPP_CXX03_LANG
783	# if _LIBCPP_STD_VER >= 17	799	# if _LIBCPP_STD_VER >= 17
784	template <class... _Args>	800	template <class... _Args>
...	@@ -791,8 +807,11 @@ public:	...	@@ -791,8 +807,11 @@ public:
791	template <class... _Args>	807	template <class... _Args>
792	_LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args);	808	_LIBCPP_HIDE_FROM_ABI void emplace_back(_Args&&... __args);
793	# endif	809	# endif
		810
794	template <class... _Args>	811	template <class... _Args>
795	_LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args);	812	_LIBCPP_HIDE_FROM_ABI iterator emplace(const_iterator __p, _Args&&... __args) {
		813	return __emplace(__p, std::forward<_Args>(__args)...);
		814	}
796		815
797	_LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);	816	_LIBCPP_HIDE_FROM_ABI void push_front(value_type&& __v);
798	_LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __v);	817	_LIBCPP_HIDE_FROM_ABI void push_back(value_type&& __v);
...	@@ -805,17 +824,21 @@ public:	...	@@ -805,17 +824,21 @@ public:
805		824
806	template <_ContainerCompatibleRange<_Tp> _Range>	825	template <_ContainerCompatibleRange<_Tp> _Range>
807	_LIBCPP_HIDE_FROM_ABI void append_range(_Range&& __range) {	826	_LIBCPP_HIDE_FROM_ABI void append_range(_Range&& __range) {
808	insert_range(end(), std::forward<_Range>(__range));	827	if constexpr (ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>) {
		828	__append_with_size(ranges::begin(__range), ranges::distance(__range));
		829	} else {
		830	__append_with_sentinel(ranges::begin(__range), ranges::end(__range));
		831	}
809	}	832	}
810	# endif	833	# endif
811		834
812	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v);	835	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) { return __emplace(__p, std::move(__v)); }
813		836
814	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, initializer_list<value_type> __il) {	837	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, initializer_list<value_type> __il) {
815	return insert(__p, __il.begin(), __il.end());	838	return insert(__p, __il.begin(), __il.end());
816	}	839	}
817	# endif // _LIBCPP_CXX03_LANG	840	# endif // _LIBCPP_CXX03_LANG
818	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v);	841	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) { return __emplace(__p, __v); }
819	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v);	842	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, size_type __n, const value_type& __v);
820	template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> = 0>	843	template <class _InputIter, __enable_if_t<__has_exactly_input_iterator_category<_InputIter>::value, int> = 0>
821	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l);	844	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, _InputIter __f, _InputIter __l);
...	@@ -1109,7 +1132,7 @@ public:	...	@@ -1109,7 +1132,7 @@ public:
1109	// This function tests deque object annotations.	1132	// This function tests deque object annotations.
1110	if (empty()) {	1133	if (empty()) {
1111	for (__map_const_iterator __it = __map_.begin(); __it != __map_.end(); ++__it) {	1134	for (__map_const_iterator __it = __map_.begin(); __it != __map_.end(); ++__it) {
1112	if (!__sanitizer_verify_double_ended_contiguous_container(	1135	if (!::__sanitizer_verify_double_ended_contiguous_container(
1113	std::__to_address(*__it),	1136	std::__to_address(*__it),
1114	std::__to_address(*__it),	1137	std::__to_address(*__it),
1115	std::__to_address(*__it),	1138	std::__to_address(*__it),
...	@@ -1141,7 +1164,7 @@ public:	...	@@ -1141,7 +1164,7 @@ public:
1141		1164
1142	// Is the block before or after deque blocks that contain elements?	1165	// Is the block before or after deque blocks that contain elements?
1143	if (__it < __first_mp \|\| __it > __last_mp) {	1166	if (__it < __first_mp \|\| __it > __last_mp) {
1144	if (!__sanitizer_verify_double_ended_contiguous_container(	1167	if (!::__sanitizer_verify_double_ended_contiguous_container(
1145	std::__to_address(*__it),	1168	std::__to_address(*__it),
1146	std::__to_address(*__it),	1169	std::__to_address(*__it),
1147	std::__to_address(*__it),	1170	std::__to_address(*__it),
...	@@ -1151,7 +1174,7 @@ public:	...	@@ -1151,7 +1174,7 @@ public:
1151	const void* __containers_buffer_beg = (__it == __first_mp) ? __p_beg : (const void)std::__to_address(__it);	1174	const void* __containers_buffer_beg = (__it == __first_mp) ? __p_beg : (const void)std::__to_address(__it);
1152	const void* __containers_buffer_end =	1175	const void* __containers_buffer_end =
1153	(__it == __last_mp) ? __p_end : (const void)std::__to_address(__it + __block_size);	1176	(__it == __last_mp) ? __p_end : (const void)std::__to_address(__it + __block_size);
1154	if (!__sanitizer_verify_double_ended_contiguous_container(	1177	if (!::__sanitizer_verify_double_ended_contiguous_container(
1155	std::__to_address(*__it),	1178	std::__to_address(*__it),
1156	__containers_buffer_beg,	1179	__containers_buffer_beg,
1157	__containers_buffer_end,	1180	__containers_buffer_end,
...	@@ -1191,7 +1214,7 @@ private:	...	@@ -1191,7 +1214,7 @@ private:
1191		1214
1192	template <class _RandomAccessIterator>	1215	template <class _RandomAccessIterator>
1193	_LIBCPP_HIDE_FROM_ABI void __assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n);	1216	_LIBCPP_HIDE_FROM_ABI void __assign_with_size_random_access(_RandomAccessIterator __f, difference_type __n);
1194	template <class _Iterator>	1217	template <class _AlgPolicy, class _Iterator>
1195	_LIBCPP_HIDE_FROM_ABI void __assign_with_size(_Iterator __f, difference_type __n);	1218	_LIBCPP_HIDE_FROM_ABI void __assign_with_size(_Iterator __f, difference_type __n);
1196		1219
1197	template <class _Iterator, class _Sentinel>	1220	template <class _Iterator, class _Sentinel>
...	@@ -1239,8 +1262,8 @@ private:	...	@@ -1239,8 +1262,8 @@ private:
1239	clear();	1262	clear();
1240	shrink_to_fit();	1263	shrink_to_fit();
1241	}	1264	}
1242	__alloc() = __c.__alloc();	1265	__alloc() = __c.__alloc();
1243	__map_.__alloc_ = __c.__map_.__alloc_;	1266	__map_.__get_allocator() = __c.__map_.__get_allocator();
1244	}	1267	}
1245		1268
1246	_LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const deque&, false_type) {}	1269	_LIBCPP_HIDE_FROM_ABI void __copy_assign_alloc(const deque&, false_type) {}
...	@@ -1256,22 +1279,22 @@ _LIBCPP_CONSTEXPR const typename allocator_traits<_Alloc>::difference_type deque	...	@@ -1256,22 +1279,22 @@ _LIBCPP_CONSTEXPR const typename allocator_traits<_Alloc>::difference_type deque
1256		1279
1257	# if _LIBCPP_STD_VER >= 17	1280	# if _LIBCPP_STD_VER >= 17
1258	template <class _InputIterator,	1281	template <class _InputIterator,
1259	class _Alloc = allocator<__iter_value_type<_InputIterator>>,	1282	class _Alloc = allocator<__iterator_value_type<_InputIterator>>,
1260	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,	1283	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
1261	class = enable_if_t<__is_allocator<_Alloc>::value> >	1284	class = enable_if_t<__is_allocator_v<_Alloc>>>
1262	deque(_InputIterator, _InputIterator) -> deque<__iter_value_type<_InputIterator>, _Alloc>;	1285	deque(_InputIterator, _InputIterator) -> deque<__iterator_value_type<_InputIterator>, _Alloc>;
1263		1286
1264	template <class _InputIterator,	1287	template <class _InputIterator,
1265	class _Alloc,	1288	class _Alloc,
1266	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,	1289	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
1267	class = enable_if_t<__is_allocator<_Alloc>::value> >	1290	class = enable_if_t<__is_allocator_v<_Alloc>>>
1268	deque(_InputIterator, _InputIterator, _Alloc) -> deque<__iter_value_type<_InputIterator>, _Alloc>;	1291	deque(_InputIterator, _InputIterator, _Alloc) -> deque<__iterator_value_type<_InputIterator>, _Alloc>;
1269	# endif	1292	# endif
1270		1293
1271	# if _LIBCPP_STD_VER >= 23	1294	# if _LIBCPP_STD_VER >= 23
1272	template <ranges::input_range _Range,	1295	template <ranges::input_range _Range,
1273	class _Alloc = allocator<ranges::range_value_t<_Range>>,	1296	class _Alloc = allocator<ranges::range_value_t<_Range>>,
1274	class = enable_if_t<__is_allocator<_Alloc>::value> >	1297	class = enable_if_t<__is_allocator_v<_Alloc>>>
1275	deque(from_range_t, _Range&&, _Alloc = _Alloc()) -> deque<ranges::range_value_t<_Range>, _Alloc>;	1298	deque(from_range_t, _Range&&, _Alloc = _Alloc()) -> deque<ranges::range_value_t<_Range>, _Alloc>;
1276	# endif	1299	# endif
1277		1300
...	@@ -1319,7 +1342,7 @@ deque<_Tp, _Allocator>::deque(const deque& __c)	...	@@ -1319,7 +1342,7 @@ deque<_Tp, _Allocator>::deque(const deque& __c)
1319	: __map_(__pointer_allocator(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))),	1342	: __map_(__pointer_allocator(__alloc_traits::select_on_container_copy_construction(__c.__alloc()))),
1320	__start_(0),	1343	__start_(0),
1321	__size_(0),	1344	__size_(0),
1322	__alloc_(__map_.__alloc_) {	1345	__alloc_(__map_.__get_allocator()) {
1323	__annotate_new(0);	1346	__annotate_new(0);
1324	__append(__c.begin(), __c.end());	1347	__append(__c.begin(), __c.end());
1325	}	1348	}
...	@@ -1451,24 +1474,6 @@ deque<_Tp, _Allocator>::__assign_with_size_random_access(_RandomAccessIterator _	...	@@ -1451,24 +1474,6 @@ deque<_Tp, _Allocator>::__assign_with_size_random_access(_RandomAccessIterator _
1451	__erase_to_end(std::copy_n(__f, __n, begin()));	1474	__erase_to_end(std::copy_n(__f, __n, begin()));
1452	}	1475	}
1453		1476
1454	template <class _Tp, class _Allocator>
1455	template <class _Iterator>
1456	_LIBCPP_HIDE_FROM_ABI void deque<_Tp, _Allocator>::__assign_with_size(_Iterator __f, difference_type __n) {
1457	if (static_cast<size_type>(__n) > size()) {
1458	auto __added_size = __n - size();
1459
1460	auto __i = begin();
1461	for (auto __count = size(); __count != 0; --__count) {
1462	__i++ = __f++;
1463	}
1464
1465	__append_with_size(__f, __added_size);
1466
1467	} else {
1468	__erase_to_end(std::copy_n(__f, __n, begin()));
1469	}
1470	}
1471
1472	template <class _Tp, class _Allocator>	1477	template <class _Tp, class _Allocator>
1473	void deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v) {	1478	void deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v) {
1474	if (__n > size()) {	1479	if (__n > size()) {
...	@@ -1661,56 +1666,11 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args) {	...	@@ -1661,56 +1666,11 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args) {
1661	return *begin();	1666	return *begin();
1662	# endif	1667	# endif
1663	}	1668	}
1664		1669	# endif // _LIBCPP_CXX03_LANG
1665	template <class _Tp, class _Allocator>
1666	typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v) {
1667	size_type __pos = __p - begin();
1668	size_type __to_end = size() - __pos;
1669	allocator_type& __a = __alloc();
1670	if (__pos < __to_end) { // insert by shifting things backward
1671	if (__front_spare() == 0)
1672	__add_front_capacity();
1673	// __front_spare() >= 1
1674	__annotate_increase_front(1);
1675	if (__pos == 0) {
1676	__alloc_traits::construct(__a, std::addressof(*--begin()), std::move(__v));
1677	--__start_;
1678	++__size();
1679	} else {
1680	iterator __b = begin();
1681	iterator __bm1 = std::prev(__b);
1682	__alloc_traits::construct(__a, std::addressof(__bm1), std::move(__b));
1683	--__start_;
1684	++__size();
1685	if (__pos > 1)
1686	__b = std::move(std::next(__b), __b + __pos, __b);
1687	*__b = std::move(__v);
1688	}
1689	} else { // insert by shifting things forward
1690	if (__back_spare() == 0)
1691	__add_back_capacity();
1692	// __back_capacity >= 1
1693	__annotate_increase_back(1);
1694	size_type __de = size() - __pos;
1695	if (__de == 0) {
1696	__alloc_traits::construct(__a, std::addressof(*end()), std::move(__v));
1697	++__size();
1698	} else {
1699	iterator __e = end();
1700	iterator __em1 = std::prev(__e);
1701	__alloc_traits::construct(__a, std::addressof(__e), std::move(__em1));
1702	++__size();
1703	if (__de > 1)
1704	__e = std::move_backward(__e - __de, __em1, __e);
1705	*--__e = std::move(__v);
1706	}
1707	}
1708	return begin() + __pos;
1709	}
1710		1670
1711	template <class _Tp, class _Allocator>	1671	template <class _Tp, class _Allocator>
1712	template <class... _Args>	1672	template <class... _Args>
1713	typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args) {	1673	typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::__emplace(const_iterator __p, _Args&&... __args) {
1714	size_type __pos = __p - begin();	1674	size_type __pos = __p - begin();
1715	size_type __to_end = size() - __pos;	1675	size_type __to_end = size() - __pos;
1716	allocator_type& __a = __alloc();	1676	allocator_type& __a = __alloc();
...	@@ -1757,60 +1717,6 @@ typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::emplace(const_	...	@@ -1757,60 +1717,6 @@ typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::emplace(const_
1757	return begin() + __pos;	1717	return begin() + __pos;
1758	}	1718	}
1759		1719
1760	# endif // _LIBCPP_CXX03_LANG
1761
1762	template <class _Tp, class _Allocator>
1763	typename deque<_Tp, _Allocator>::iterator deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v) {
1764	size_type __pos = __p - begin();
1765	size_type __to_end = size() - __pos;
1766	allocator_type& __a = __alloc();
1767	if (__pos < __to_end) { // insert by shifting things backward
1768	if (__front_spare() == 0)
1769	__add_front_capacity();
1770	// __front_spare() >= 1
1771	__annotate_increase_front(1);
1772	if (__pos == 0) {
1773	__alloc_traits::construct(__a, std::addressof(*--begin()), __v);
1774	--__start_;
1775	++__size();
1776	} else {
1777	const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
1778	iterator __b = begin();
1779	iterator __bm1 = std::prev(__b);
1780	if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
1781	__vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
1782	__alloc_traits::construct(__a, std::addressof(__bm1), std::move(__b));
1783	--__start_;
1784	++__size();
1785	if (__pos > 1)
1786	__b = __move_and_check(std::next(__b), __b + __pos, __b, __vt);
1787	__b = __vt;
1788	}
1789	} else { // insert by shifting things forward
1790	if (__back_spare() == 0)
1791	__add_back_capacity();
1792	// __back_capacity >= 1
1793	__annotate_increase_back(1);
1794	size_type __de = size() - __pos;
1795	if (__de == 0) {
1796	__alloc_traits::construct(__a, std::addressof(*end()), __v);
1797	++__size();
1798	} else {
1799	const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
1800	iterator __e = end();
1801	iterator __em1 = std::prev(__e);
1802	if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
1803	__vt = pointer_traits<const_pointer>::pointer_to(*__e);
1804	__alloc_traits::construct(__a, std::addressof(__e), std::move(__em1));
1805	++__size();
1806	if (__de > 1)
1807	__e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
1808	--__e = __vt;
1809	}
1810	}
1811	return begin() + __pos;
1812	}
1813
1814	template <class _Tp, class _Allocator>	1720	template <class _Tp, class _Allocator>
1815	typename deque<_Tp, _Allocator>::iterator	1721	typename deque<_Tp, _Allocator>::iterator
1816	deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v) {	1722	deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_type& __v) {
...	@@ -1874,9 +1780,9 @@ template <class _Tp, class _Allocator>	...	@@ -1874,9 +1780,9 @@ template <class _Tp, class _Allocator>
1874	template <class _Iterator, class _Sentinel>	1780	template <class _Iterator, class _Sentinel>
1875	_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator	1781	_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator
1876	deque<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {	1782	deque<_Tp, _Allocator>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Sentinel __l) {
1877	__split_buffer<value_type, allocator_type&> __buf(__alloc());	1783	__split_buffer<value_type, allocator_type> __buf(__alloc());
1878	__buf.__construct_at_end_with_sentinel(std::move(__f), std::move(__l));	1784	__buf.__construct_at_end_with_sentinel(std::move(__f), std::move(__l));
1879	typedef typename __split_buffer<value_type, allocator_type&>::iterator __bi;	1785	typedef typename __split_buffer<value_type, allocator_type>::iterator __bi;
1880	return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));	1786	return insert(__p, move_iterator<__bi>(__buf.begin()), move_iterator<__bi>(__buf.end()));
1881	}	1787	}
1882		1788
...	@@ -1891,9 +1797,9 @@ template <class _Tp, class _Allocator>	...	@@ -1891,9 +1797,9 @@ template <class _Tp, class _Allocator>
1891	template <class _Iterator>	1797	template <class _Iterator>
1892	_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator	1798	_LIBCPP_HIDE_FROM_ABI typename deque<_Tp, _Allocator>::iterator
1893	deque<_Tp, _Allocator>::__insert_with_size(const_iterator __p, _Iterator __f, size_type __n) {	1799	deque<_Tp, _Allocator>::__insert_with_size(const_iterator __p, _Iterator __f, size_type __n) {
1894	__split_buffer<value_type, allocator_type&> __buf(__n, 0, __alloc());	1800	__split_buffer<value_type, allocator_type> __buf(__n, 0, __alloc());
1895	__buf.__construct_at_end_with_size(__f, __n);	1801	__buf.__construct_at_end_with_size(std::move(__f), __n);
1896	typedef typename __split_buffer<value_type, allocator_type&>::iterator __fwd;	1802	typedef typename __split_buffer<value_type, allocator_type>::iterator __fwd;
1897	return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));	1803	return insert(__p, move_iterator<__fwd>(__buf.begin()), move_iterator<__fwd>(__buf.end()));
1898	}	1804	}
1899		1805
...	@@ -2071,8 +1977,8 @@ void deque<_Tp, _Allocator>::__add_front_capacity() {	...	@@ -2071,8 +1977,8 @@ void deque<_Tp, _Allocator>::__add_front_capacity() {
2071	}	1977	}
2072	// Else need to allocate 1 buffer, and we need to reallocate __map_.	1978	// Else need to allocate 1 buffer, and we need to reallocate __map_.
2073	else {	1979	else {
2074	__split_buffer<pointer, __pointer_allocator&> __buf(	1980	__split_buffer<pointer, __pointer_allocator> __buf(
2075	std::max<size_type>(2 * __map_.capacity(), 1), 0, __map_.__alloc_);	1981	std::max<size_type>(2 * __map_.capacity(), 1), 0, __map_.__get_allocator());
2076		1982
2077	typedef __allocator_destructor<_Allocator> _Dp;	1983	typedef __allocator_destructor<_Allocator> _Dp;
2078	unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __block_size), _Dp(__a, __block_size));	1984	unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __block_size), _Dp(__a, __block_size));
...	@@ -2081,10 +1987,7 @@ void deque<_Tp, _Allocator>::__add_front_capacity() {	...	@@ -2081,10 +1987,7 @@ void deque<_Tp, _Allocator>::__add_front_capacity() {
2081		1987
2082	for (__map_pointer __i = __map_.begin(); __i != __map_.end(); ++__i)	1988	for (__map_pointer __i = __map_.begin(); __i != __map_.end(); ++__i)
2083	__buf.emplace_back(*__i);	1989	__buf.emplace_back(*__i);
2084	std::swap(__map_.__first_, __buf.__first_);	1990	__map_.__swap_without_allocator(__buf);
2085	std::swap(__map_.__begin_, __buf.__begin_);
2086	std::swap(__map_.__end_, __buf.__end_);
2087	std::swap(__map_.__cap_, __buf.__cap_);
2088	__start_ = __map_.size() == 1 ? __block_size / 2 : __start_ + __block_size;	1991	__start_ = __map_.size() == 1 ? __block_size / 2 : __start_ + __block_size;
2089	}	1992	}
2090	__annotate_whole_block(0, __asan_poison);	1993	__annotate_whole_block(0, __asan_poison);
...	@@ -2134,34 +2037,26 @@ void deque<_Tp, _Allocator>::__add_front_capacity(size_type __n) {	...	@@ -2134,34 +2037,26 @@ void deque<_Tp, _Allocator>::__add_front_capacity(size_type __n) {
2134	// Else need to allocate __nb buffers, and we need to reallocate __map_.	2037	// Else need to allocate __nb buffers, and we need to reallocate __map_.
2135	else {	2038	else {
2136	size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();	2039	size_type __ds = (__nb + __back_capacity) * __block_size - __map_.empty();
2137	__split_buffer<pointer, __pointer_allocator&> __buf(	2040	__split_buffer<pointer, __pointer_allocator> __buf(
2138	std::max<size_type>(2 * __map_.capacity(), __nb + __map_.size()), 0, __map_.__alloc_);	2041	std::max<size_type>(2 * __map_.capacity(), __nb + __map_.size()), 0, __map_.__get_allocator());
2139	# if _LIBCPP_HAS_EXCEPTIONS	2042	auto __guard = std::__make_exception_guard([&] {
2140	try {
2141	# endif // _LIBCPP_HAS_EXCEPTIONS
2142	for (; __nb > 0; --__nb) {
2143	__buf.emplace_back(__alloc_traits::allocate(__a, __block_size));
2144	// ASan: this is empty container, we have to poison whole block
2145	__annotate_poison_block(std::__to_address(__buf.back()), std::__to_address(__buf.back() + __block_size));
2146	}
2147	# if _LIBCPP_HAS_EXCEPTIONS
2148	} catch (...) {
2149	__annotate_delete();	2043	__annotate_delete();
2150	for (__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)	2044	for (__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)
2151	__alloc_traits::deallocate(__a, *__i, __block_size);	2045	__alloc_traits::deallocate(__a, *__i, __block_size);
2152	throw;	2046	});
		2047	for (; __nb > 0; --__nb) {
		2048	__buf.emplace_back(__alloc_traits::allocate(__a, __block_size));
		2049	// ASan: this is empty container, we have to poison whole block
		2050	__annotate_poison_block(std::__to_address(__buf.back()), std::__to_address(__buf.back() + __block_size));
2153	}	2051	}
2154	# endif // _LIBCPP_HAS_EXCEPTIONS	2052	__guard.__complete();
2155	for (; __back_capacity > 0; --__back_capacity) {	2053	for (; __back_capacity > 0; --__back_capacity) {
2156	__buf.emplace_back(__map_.back());	2054	__buf.emplace_back(__map_.back());
2157	__map_.pop_back();	2055	__map_.pop_back();
2158	}	2056	}
2159	for (__map_pointer __i = __map_.begin(); __i != __map_.end(); ++__i)	2057	for (__map_pointer __i = __map_.begin(); __i != __map_.end(); ++__i)
2160	__buf.emplace_back(*__i);	2058	__buf.emplace_back(*__i);
2161	std::swap(__map_.__first_, __buf.__first_);	2059	__map_.__swap_without_allocator(__buf);
2162	std::swap(__map_.__begin_, __buf.__begin_);
2163	std::swap(__map_.__end_, __buf.__end_);
2164	std::swap(__map_.__cap_, __buf.__cap_);
2165	__start_ += __ds;	2060	__start_ += __ds;
2166	}	2061	}
2167	}	2062	}
...	@@ -2194,8 +2089,8 @@ void deque<_Tp, _Allocator>::__add_back_capacity() {	...	@@ -2194,8 +2089,8 @@ void deque<_Tp, _Allocator>::__add_back_capacity() {
2194	}	2089	}
2195	// Else need to allocate 1 buffer, and we need to reallocate __map_.	2090	// Else need to allocate 1 buffer, and we need to reallocate __map_.
2196	else {	2091	else {
2197	__split_buffer<pointer, __pointer_allocator&> __buf(	2092	__split_buffer<pointer, __pointer_allocator> __buf(
2198	std::max<size_type>(2 * __map_.capacity(), 1), __map_.size(), __map_.__alloc_);	2093	std::max<size_type>(2 * __map_.capacity(), 1), __map_.size(), __map_.__get_allocator());
2199		2094
2200	typedef __allocator_destructor<_Allocator> _Dp;	2095	typedef __allocator_destructor<_Allocator> _Dp;
2201	unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __block_size), _Dp(__a, __block_size));	2096	unique_ptr<pointer, _Dp> __hold(__alloc_traits::allocate(__a, __block_size), _Dp(__a, __block_size));
...	@@ -2204,10 +2099,7 @@ void deque<_Tp, _Allocator>::__add_back_capacity() {	...	@@ -2204,10 +2099,7 @@ void deque<_Tp, _Allocator>::__add_back_capacity() {
2204		2099
2205	for (__map_pointer __i = __map_.end(); __i != __map_.begin();)	2100	for (__map_pointer __i = __map_.end(); __i != __map_.begin();)
2206	__buf.emplace_front(*--__i);	2101	__buf.emplace_front(*--__i);
2207	std::swap(__map_.__first_, __buf.__first_);	2102	__map_.__swap_without_allocator(__buf);
2208	std::swap(__map_.__begin_, __buf.__begin_);
2209	std::swap(__map_.__end_, __buf.__end_);
2210	std::swap(__map_.__cap_, __buf.__cap_);
2211	__annotate_whole_block(__map_.size() - 1, __asan_poison);	2103	__annotate_whole_block(__map_.size() - 1, __asan_poison);
2212	}	2104	}
2213	}	2105	}
...	@@ -2257,36 +2149,28 @@ void deque<_Tp, _Allocator>::__add_back_capacity(size_type __n) {	...	@@ -2257,36 +2149,28 @@ void deque<_Tp, _Allocator>::__add_back_capacity(size_type __n) {
2257	// Else need to allocate __nb buffers, and we need to reallocate __map_.	2149	// Else need to allocate __nb buffers, and we need to reallocate __map_.
2258	else {	2150	else {
2259	size_type __ds = __front_capacity * __block_size;	2151	size_type __ds = __front_capacity * __block_size;
2260	__split_buffer<pointer, __pointer_allocator&> __buf(	2152	__split_buffer<pointer, __pointer_allocator> __buf(
2261	std::max<size_type>(2 * __map_.capacity(), __nb + __map_.size()),	2153	std::max<size_type>(2 * __map_.capacity(), __nb + __map_.size()),
2262	__map_.size() - __front_capacity,	2154	__map_.size() - __front_capacity,
2263	__map_.__alloc_);	2155	__map_.__get_allocator());
2264	# if _LIBCPP_HAS_EXCEPTIONS	2156	auto __guard = std::__make_exception_guard([&] {
2265	try {
2266	# endif // _LIBCPP_HAS_EXCEPTIONS
2267	for (; __nb > 0; --__nb) {
2268	__buf.emplace_back(__alloc_traits::allocate(__a, __block_size));
2269	// ASan: this is an empty container, we have to poison the whole block
2270	__annotate_poison_block(std::__to_address(__buf.back()), std::__to_address(__buf.back() + __block_size));
2271	}
2272	# if _LIBCPP_HAS_EXCEPTIONS
2273	} catch (...) {
2274	__annotate_delete();	2157	__annotate_delete();
2275	for (__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)	2158	for (__map_pointer __i = __buf.begin(); __i != __buf.end(); ++__i)
2276	__alloc_traits::deallocate(__a, *__i, __block_size);	2159	__alloc_traits::deallocate(__a, *__i, __block_size);
2277	throw;	2160	});
		2161	for (; __nb > 0; --__nb) {
		2162	__buf.emplace_back(__alloc_traits::allocate(__a, __block_size));
		2163	// ASan: this is an empty container, we have to poison the whole block
		2164	__annotate_poison_block(std::__to_address(__buf.back()), std::__to_address(__buf.back() + __block_size));
2278	}	2165	}
2279	# endif // _LIBCPP_HAS_EXCEPTIONS	2166	__guard.__complete();
2280	for (; __front_capacity > 0; --__front_capacity) {	2167	for (; __front_capacity > 0; --__front_capacity) {
2281	__buf.emplace_back(__map_.front());	2168	__buf.emplace_back(__map_.front());
2282	__map_.pop_front();	2169	__map_.pop_front();
2283	}	2170	}
2284	for (__map_pointer __i = __map_.end(); __i != __map_.begin();)	2171	for (__map_pointer __i = __map_.end(); __i != __map_.begin();)
2285	__buf.emplace_front(*--__i);	2172	__buf.emplace_front(*--__i);
2286	std::swap(__map_.__first_, __buf.__first_);	2173	__map_.__swap_without_allocator(__buf);
2287	std::swap(__map_.__begin_, __buf.__begin_);
2288	std::swap(__map_.__end_, __buf.__end_);
2289	std::swap(__map_.__cap_, __buf.__cap_);
2290	__start_ -= __ds;	2174	__start_ -= __ds;
2291	}	2175	}
2292	}	2176	}

lib/libcxx/include/errno.h+269-269

...	@@ -23,381 +23,381 @@ Macros:	...	@@ -23,381 +23,381 @@ Macros:
23	*/	23	*/
24		24
25	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	25	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
26	# include <__cxx03/errno.h>	26	# include <__cxx03/__config>
27	#else	27	#else
28	# include <__config>	28	# include <__config>
		29	#endif
29		30
30	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	31	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
31	# pragma GCC system_header	32	# pragma GCC system_header
32	# endif	33	#endif
33		34
34	# if __has_include_next(<errno.h>)	35	#if __has_include_next(<errno.h>)
35	# include_next <errno.h>	36	# include_next <errno.h>
36	# endif	37	#endif
37		38
38	# ifdef __cplusplus	39	#ifdef __cplusplus
39		40
40	# if !defined(EOWNERDEAD) \|\| !defined(ENOTRECOVERABLE)	41	# if !defined(EOWNERDEAD) \|\| !defined(ENOTRECOVERABLE)
41		42
42	# ifdef ELAST	43	# ifdef ELAST
43		44
44	static const int __elast1 = ELAST + 1;	45	static const int __elast1 = ELAST + 1;
45	static const int __elast2 = ELAST + 2;	46	static const int __elast2 = ELAST + 2;
46		47
47	# else	48	# else
48		49
49	static const int __elast1 = 104;	50	static const int __elast1 = 104;
50	static const int __elast2 = 105;	51	static const int __elast2 = 105;
51		52
52	# endif	53	# endif
53		54
54	# ifdef ENOTRECOVERABLE	55	# ifdef ENOTRECOVERABLE
55		56
56	# define EOWNERDEAD __elast1	57	# define EOWNERDEAD __elast1
57		58
58	# ifdef ELAST	59	# ifdef ELAST
59	# undef ELAST	60	# undef ELAST
60	# define ELAST EOWNERDEAD	61	# define ELAST EOWNERDEAD
61	# endif	62	# endif
62		63
63	# elif defined(EOWNERDEAD)	64	# elif defined(EOWNERDEAD)
64		65
65	# define ENOTRECOVERABLE __elast1	66	# define ENOTRECOVERABLE __elast1
66	# ifdef ELAST	67	# ifdef ELAST
67	# undef ELAST	68	# undef ELAST
68	# define ELAST ENOTRECOVERABLE	69	# define ELAST ENOTRECOVERABLE
69	# endif	70	# endif
70		71
71	# else // defined(EOWNERDEAD)	72	# else // defined(EOWNERDEAD)
72		73
73	# define EOWNERDEAD __elast1	74	# define EOWNERDEAD __elast1
74	# define ENOTRECOVERABLE __elast2	75	# define ENOTRECOVERABLE __elast2
75	# ifdef ELAST	76	# ifdef ELAST
76	# undef ELAST	77	# undef ELAST
77	# define ELAST ENOTRECOVERABLE	78	# define ELAST ENOTRECOVERABLE
78	# endif	79	# endif
79		80
80	# endif // defined(EOWNERDEAD)	81	# endif // defined(EOWNERDEAD)
81		82
82	# endif // !defined(EOWNERDEAD) \|\| !defined(ENOTRECOVERABLE)	83	# endif // !defined(EOWNERDEAD) \|\| !defined(ENOTRECOVERABLE)
83		84
84	// supply errno values likely to be missing, particularly on Windows	85	// supply errno values likely to be missing, particularly on Windows
85		86
86	# ifndef EAFNOSUPPORT	87	# ifndef EAFNOSUPPORT
87	# define EAFNOSUPPORT 9901	88	# define EAFNOSUPPORT 9901
88	# endif	89	# endif
89		90
90	# ifndef EADDRINUSE	91	# ifndef EADDRINUSE
91	# define EADDRINUSE 9902	92	# define EADDRINUSE 9902
92	# endif	93	# endif
93		94
94	# ifndef EADDRNOTAVAIL	95	# ifndef EADDRNOTAVAIL
95	# define EADDRNOTAVAIL 9903	96	# define EADDRNOTAVAIL 9903
96	# endif	97	# endif
97		98
98	# ifndef EISCONN	99	# ifndef EISCONN
99	# define EISCONN 9904	100	# define EISCONN 9904
100	# endif	101	# endif
101		102
102	# ifndef EBADMSG	103	# ifndef EBADMSG
103	# define EBADMSG 9905	104	# define EBADMSG 9905
104	# endif	105	# endif
105		106
106	# ifndef ECONNABORTED	107	# ifndef ECONNABORTED
107	# define ECONNABORTED 9906	108	# define ECONNABORTED 9906
108	# endif	109	# endif
109		110
110	# ifndef EALREADY	111	# ifndef EALREADY
111	# define EALREADY 9907	112	# define EALREADY 9907
112	# endif	113	# endif
113		114
114	# ifndef ECONNREFUSED	115	# ifndef ECONNREFUSED
115	# define ECONNREFUSED 9908	116	# define ECONNREFUSED 9908
116	# endif	117	# endif
117		118
118	# ifndef ECONNRESET	119	# ifndef ECONNRESET
119	# define ECONNRESET 9909	120	# define ECONNRESET 9909
120	# endif	121	# endif
121		122
122	# ifndef EDESTADDRREQ	123	# ifndef EDESTADDRREQ
123	# define EDESTADDRREQ 9910	124	# define EDESTADDRREQ 9910
124	# endif	125	# endif
125		126
126	# ifndef EHOSTUNREACH	127	# ifndef EHOSTUNREACH
127	# define EHOSTUNREACH 9911	128	# define EHOSTUNREACH 9911
128	# endif	129	# endif
129		130
130	# ifndef EIDRM	131	# ifndef EIDRM
131	# define EIDRM 9912	132	# define EIDRM 9912
132	# endif	133	# endif
133		134
134	# ifndef EMSGSIZE	135	# ifndef EMSGSIZE
135	# define EMSGSIZE 9913	136	# define EMSGSIZE 9913
136	# endif	137	# endif
137		138
138	# ifndef ENETDOWN	139	# ifndef ENETDOWN
139	# define ENETDOWN 9914	140	# define ENETDOWN 9914
140	# endif	141	# endif
141		142
142	# ifndef ENETRESET	143	# ifndef ENETRESET
143	# define ENETRESET 9915	144	# define ENETRESET 9915
144	# endif	145	# endif
145		146
146	# ifndef ENETUNREACH	147	# ifndef ENETUNREACH
147	# define ENETUNREACH 9916	148	# define ENETUNREACH 9916
148	# endif	149	# endif
149		150
150	# ifndef ENOBUFS	151	# ifndef ENOBUFS
151	# define ENOBUFS 9917	152	# define ENOBUFS 9917
152	# endif	153	# endif
153		154
154	# ifndef ENOLINK	155	# ifndef ENOLINK
155	# define ENOLINK 9918	156	# define ENOLINK 9918
156	# endif	157	# endif
157		158
158	# ifndef ENODATA	159	# ifndef ENODATA
159	# define ENODATA 9919	160	# define ENODATA 9919
160	# endif	161	# endif
161		162
162	# ifndef ENOMSG	163	# ifndef ENOMSG
163	# define ENOMSG 9920	164	# define ENOMSG 9920
164	# endif	165	# endif
165		166
166	# ifndef ENOPROTOOPT	167	# ifndef ENOPROTOOPT
167	# define ENOPROTOOPT 9921	168	# define ENOPROTOOPT 9921
168	# endif	169	# endif
169		170
170	# ifndef ENOSR	171	# ifndef ENOSR
171	# define ENOSR 9922	172	# define ENOSR 9922
172	# endif	173	# endif
173		174
174	# ifndef ENOTSOCK	175	# ifndef ENOTSOCK
175	# define ENOTSOCK 9923	176	# define ENOTSOCK 9923
176	# endif	177	# endif
177		178
178	# ifndef ENOSTR	179	# ifndef ENOSTR
179	# define ENOSTR 9924	180	# define ENOSTR 9924
180	# endif	181	# endif
181		182
182	# ifndef ENOTCONN	183	# ifndef ENOTCONN
183	# define ENOTCONN 9925	184	# define ENOTCONN 9925
184	# endif	185	# endif
185		186
186	# ifndef ENOTSUP	187	# ifndef ENOTSUP
187	# define ENOTSUP 9926	188	# define ENOTSUP 9926
188	# endif	189	# endif
189		190
190	# ifndef ECANCELED	191	# ifndef ECANCELED
191	# define ECANCELED 9927	192	# define ECANCELED 9927
192	# endif	193	# endif
193		194
194	# ifndef EINPROGRESS	195	# ifndef EINPROGRESS
195	# define EINPROGRESS 9928	196	# define EINPROGRESS 9928
196	# endif	197	# endif
197		198
198	# ifndef EOPNOTSUPP	199	# ifndef EOPNOTSUPP
199	# define EOPNOTSUPP 9929	200	# define EOPNOTSUPP 9929
200	# endif	201	# endif
201		202
202	# ifndef EWOULDBLOCK	203	# ifndef EWOULDBLOCK
203	# define EWOULDBLOCK 9930	204	# define EWOULDBLOCK 9930
204	# endif	205	# endif
205		206
206	# ifndef EOWNERDEAD	207	# ifndef EOWNERDEAD
207	# define EOWNERDEAD 9931	208	# define EOWNERDEAD 9931
208	# endif	209	# endif
209		210
210	# ifndef EPROTO	211	# ifndef EPROTO
211	# define EPROTO 9932	212	# define EPROTO 9932
212	# endif	213	# endif
213		214
214	# ifndef EPROTONOSUPPORT	215	# ifndef EPROTONOSUPPORT
215	# define EPROTONOSUPPORT 9933	216	# define EPROTONOSUPPORT 9933
216	# endif	217	# endif
217		218
218	# ifndef ENOTRECOVERABLE	219	# ifndef ENOTRECOVERABLE
219	# define ENOTRECOVERABLE 9934	220	# define ENOTRECOVERABLE 9934
220	# endif	221	# endif
221		222
222	# ifndef ETIME	223	# ifndef ETIME
223	# define ETIME 9935	224	# define ETIME 9935
224	# endif	225	# endif
225		226
226	# ifndef ETXTBSY	227	# ifndef ETXTBSY
227	# define ETXTBSY 9936	228	# define ETXTBSY 9936
228	# endif	229	# endif
229		230
230	# ifndef ETIMEDOUT	231	# ifndef ETIMEDOUT
231	# define ETIMEDOUT 9938	232	# define ETIMEDOUT 9938
232	# endif	233	# endif
233		234
234	# ifndef ELOOP	235	# ifndef ELOOP
235	# define ELOOP 9939	236	# define ELOOP 9939
236	# endif	237	# endif
237		238
238	# ifndef EOVERFLOW	239	# ifndef EOVERFLOW
239	# define EOVERFLOW 9940	240	# define EOVERFLOW 9940
240	# endif	241	# endif
241		242
242	# ifndef EPROTOTYPE	243	# ifndef EPROTOTYPE
243	# define EPROTOTYPE 9941	244	# define EPROTOTYPE 9941
244	# endif	245	# endif
245		246
246	# ifndef ENOSYS	247	# ifndef ENOSYS
247	# define ENOSYS 9942	248	# define ENOSYS 9942
248	# endif	249	# endif
249		250
250	# ifndef EINVAL	251	# ifndef EINVAL
251	# define EINVAL 9943	252	# define EINVAL 9943
252	# endif	253	# endif
253		254
254	# ifndef ERANGE	255	# ifndef ERANGE
255	# define ERANGE 9944	256	# define ERANGE 9944
256	# endif	257	# endif
257		258
258	# ifndef EILSEQ	259	# ifndef EILSEQ
259	# define EILSEQ 9945	260	# define EILSEQ 9945
260	# endif	261	# endif
261		262
262	// Windows Mobile doesn't appear to define these:	263	// Windows Mobile doesn't appear to define these:
263		264
264	# ifndef E2BIG	265	# ifndef E2BIG
265	# define E2BIG 9946	266	# define E2BIG 9946
266	# endif	267	# endif
267		268
268	# ifndef EDOM	269	# ifndef EDOM
269	# define EDOM 9947	270	# define EDOM 9947
270	# endif	271	# endif
271		272
272	# ifndef EFAULT	273	# ifndef EFAULT
273	# define EFAULT 9948	274	# define EFAULT 9948
274	# endif	275	# endif
275		276
276	# ifndef EBADF	277	# ifndef EBADF
277	# define EBADF 9949	278	# define EBADF 9949
278	# endif	279	# endif
279		280
280	# ifndef EPIPE	281	# ifndef EPIPE
281	# define EPIPE 9950	282	# define EPIPE 9950
282	# endif	283	# endif
283		284
284	# ifndef EXDEV	285	# ifndef EXDEV
285	# define EXDEV 9951	286	# define EXDEV 9951
286	# endif	287	# endif
287		288
288	# ifndef EBUSY	289	# ifndef EBUSY
289	# define EBUSY 9952	290	# define EBUSY 9952
290	# endif	291	# endif
291		292
292	# ifndef ENOTEMPTY	293	# ifndef ENOTEMPTY
293	# define ENOTEMPTY 9953	294	# define ENOTEMPTY 9953
294	# endif	295	# endif
295		296
296	# ifndef ENOEXEC	297	# ifndef ENOEXEC
297	# define ENOEXEC 9954	298	# define ENOEXEC 9954
298	# endif	299	# endif
299		300
300	# ifndef EEXIST	301	# ifndef EEXIST
301	# define EEXIST 9955	302	# define EEXIST 9955
302	# endif	303	# endif
303		304
304	# ifndef EFBIG	305	# ifndef EFBIG
305	# define EFBIG 9956	306	# define EFBIG 9956
306	# endif	307	# endif
307		308
308	# ifndef ENAMETOOLONG	309	# ifndef ENAMETOOLONG
309	# define ENAMETOOLONG 9957	310	# define ENAMETOOLONG 9957
310	# endif	311	# endif
311		312
312	# ifndef ENOTTY	313	# ifndef ENOTTY
313	# define ENOTTY 9958	314	# define ENOTTY 9958
314	# endif	315	# endif
315		316
316	# ifndef EINTR	317	# ifndef EINTR
317	# define EINTR 9959	318	# define EINTR 9959
318	# endif	319	# endif
319		320
320	# ifndef ESPIPE	321	# ifndef ESPIPE
321	# define ESPIPE 9960	322	# define ESPIPE 9960
322	# endif	323	# endif
323		324
324	# ifndef EIO	325	# ifndef EIO
325	# define EIO 9961	326	# define EIO 9961
326	# endif	327	# endif
327		328
328	# ifndef EISDIR	329	# ifndef EISDIR
329	# define EISDIR 9962	330	# define EISDIR 9962
330	# endif	331	# endif
331		332
332	# ifndef ECHILD	333	# ifndef ECHILD
333	# define ECHILD 9963	334	# define ECHILD 9963
334	# endif	335	# endif
335		336
336	# ifndef ENOLCK	337	# ifndef ENOLCK
337	# define ENOLCK 9964	338	# define ENOLCK 9964
338	# endif	339	# endif
339		340
340	# ifndef ENOSPC	341	# ifndef ENOSPC
341	# define ENOSPC 9965	342	# define ENOSPC 9965
342	# endif	343	# endif
343		344
344	# ifndef ENXIO	345	# ifndef ENXIO
345	# define ENXIO 9966	346	# define ENXIO 9966
346	# endif	347	# endif
347		348
348	# ifndef ENODEV	349	# ifndef ENODEV
349	# define ENODEV 9967	350	# define ENODEV 9967
350	# endif	351	# endif
351		352
352	# ifndef ENOENT	353	# ifndef ENOENT
353	# define ENOENT 9968	354	# define ENOENT 9968
354	# endif	355	# endif
355		356
356	# ifndef ESRCH	357	# ifndef ESRCH
357	# define ESRCH 9969	358	# define ESRCH 9969
358	# endif	359	# endif
359		360
360	# ifndef ENOTDIR	361	# ifndef ENOTDIR
361	# define ENOTDIR 9970	362	# define ENOTDIR 9970
362	# endif	363	# endif
363		364
364	# ifndef ENOMEM	365	# ifndef ENOMEM
365	# define ENOMEM 9971	366	# define ENOMEM 9971
366	# endif	367	# endif
367		368
368	# ifndef EPERM	369	# ifndef EPERM
369	# define EPERM 9972	370	# define EPERM 9972
370	# endif	371	# endif
371		372
372	# ifndef EACCES	373	# ifndef EACCES
373	# define EACCES 9973	374	# define EACCES 9973
374	# endif	375	# endif
375		376
376	# ifndef EROFS	377	# ifndef EROFS
377	# define EROFS 9974	378	# define EROFS 9974
378	# endif	379	# endif
379		380
380	# ifndef EDEADLK	381	# ifndef EDEADLK
381	# define EDEADLK 9975	382	# define EDEADLK 9975
382	# endif	383	# endif
383		384
384	# ifndef EAGAIN	385	# ifndef EAGAIN
385	# define EAGAIN 9976	386	# define EAGAIN 9976
386	# endif	387	# endif
387		388
388	# ifndef ENFILE	389	# ifndef ENFILE
389	# define ENFILE 9977	390	# define ENFILE 9977
390	# endif	391	# endif
391		392
392	# ifndef EMFILE	393	# ifndef EMFILE
393	# define EMFILE 9978	394	# define EMFILE 9978
394	# endif	395	# endif
395		396
396	# ifndef EMLINK	397	# ifndef EMLINK
397	# define EMLINK 9979	398	# define EMLINK 9979
398	# endif	399	# endif
399		400
400	# endif // __cplusplus	401	#endif // __cplusplus
401	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
402		402
403	#endif // _LIBCPP_ERRNO_H	403	#endif // _LIBCPP_ERRNO_H

lib/libcxx/include/exception+4-1

 @@ -93,10 +93,13 @@ template <class E> void rethrow_if_nested(const E& e);
 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #    include <cstddef>
-#    include <cstdlib>
 #    include <new>
 #    include <type_traits>
 #  endif
+#  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 23
+#    include <cstdlib>
+#  endif
 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
 #endif // _LIBCPP_EXCEPTION

lib/libcxx/include/ext/hash_map+7-48

 @@ -206,6 +206,7 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #else
 #  include <__config>
 #  include <__hash_table>
+#  include <__memory/compressed_pair.h>
 #  include <algorithm>
 #  include <ext/__hash>
 #  include <functional>
 @@ -224,21 +225,9 @@ _LIBCPP_WARNING("Use of the header <ext/hash_map> is deprecated.  Migrate to <un
 namespace __gnu_cxx {
-template <class _Tp, class _Hash, bool = std::is_empty<_Hash>::value && !std::__libcpp_is_final<_Hash>::value >
-class __hash_map_hasher : private _Hash {
-public:
-  _LIBCPP_HIDE_FROM_ABI __hash_map_hasher() : _Hash() {}
-  _LIBCPP_HIDE_FROM_ABI __hash_map_hasher(const _Hash& __h) : _Hash(__h) {}
-  _LIBCPP_HIDE_FROM_ABI const _Hash& hash_function() const { return *this; }
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Tp& __x) const { return static_cast<const _Hash&>(*this)(__x.first); }
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const typename _Tp::first_type& __x) const {
-    return static_cast<const _Hash&>(*this)(__x);
-  }
-};
 template <class _Tp, class _Hash>
-class __hash_map_hasher<_Tp, _Hash, false> {
+class __hash_map_hasher {
-  _Hash __hash_;
+  _LIBCPP_COMPRESSED_ELEMENT(_Hash, __hash_);
 public:
   _LIBCPP_HIDE_FROM_ABI __hash_map_hasher() : __hash_() {}
 @@ -248,30 +237,9 @@ public:
   _LIBCPP_HIDE_FROM_ABI size_t operator()(const typename _Tp::first_type& __x) const { return __hash_(__x); }
 };
-template <class _Tp, class _Pred, bool = std::is_empty<_Pred>::value && !std::__libcpp_is_final<_Pred>::value >
-class __hash_map_equal : private _Pred {
-public:
-  _LIBCPP_HIDE_FROM_ABI __hash_map_equal() : _Pred() {}
-  _LIBCPP_HIDE_FROM_ABI __hash_map_equal(const _Pred& __p) : _Pred(__p) {}
-  _LIBCPP_HIDE_FROM_ABI const _Pred& key_eq() const { return *this; }
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const _Tp& __y) const {
-    return static_cast<const _Pred&>(*this)(__x.first, __y.first);
-  }
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const typename _Tp::first_type& __x, const _Tp& __y) const {
-    return static_cast<const _Pred&>(*this)(__x, __y.first);
-  }
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Tp& __x, const typename _Tp::first_type& __y) const {
-    return static_cast<const _Pred&>(*this)(__x.first, __y);
-  }
-  _LIBCPP_HIDE_FROM_ABI bool
-  operator()(const typename _Tp::first_type& __x, const typename _Tp::first_type& __y) const {
-    return static_cast<const _Pred&>(*this)(__x, __y);
-  }
-};
 template <class _Tp, class _Pred>
-class __hash_map_equal<_Tp, _Pred, false> {
+class __hash_map_equal {
-  _Pred __pred_;
+  _LIBCPP_COMPRESSED_ELEMENT(_Pred, __pred_);
 public:
   _LIBCPP_HIDE_FROM_ABI __hash_map_equal() : __pred_() {}
 @@ -467,8 +435,6 @@ private:
   __table __table_;
-  typedef typename __table::__node_pointer __node_pointer;
-  typedef typename __table::__node_const_pointer __node_const_pointer;
   typedef typename __table::__node_traits __node_traits;
   typedef typename __table::__node_allocator __node_allocator;
   typedef typename __table::__node __node;
 @@ -604,10 +570,7 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(
 }
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(const hash_map& __u) : __table_(__u.__table_) {
+hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_map(const hash_map& __u) : __table_(__u.__table_) {}
-  __table_.__rehash_unique(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 typename hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 @@ -693,7 +656,6 @@ private:
   __table __table_;
-  typedef typename __table::__node_traits __node_traits;
   typedef typename __table::__node_allocator __node_allocator;
   typedef typename __table::__node __node;
   typedef __hash_map_node_destructor<__node_allocator> _Dp;
 @@ -822,10 +784,7 @@ hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(
 }
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(const hash_multimap& __u) : __table_(__u.__table_) {
+hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::hash_multimap(const hash_multimap& __u) : __table_(__u.__table_) {}
-  __table_.__rehash_multi(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>

lib/libcxx/include/ext/hash_set+2-8

 @@ -356,10 +356,7 @@ hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(
 }
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(const hash_set& __u) : __table_(__u.__table_) {
+hash_set<_Value, _Hash, _Pred, _Alloc>::hash_set(const hash_set& __u) : __table_(__u.__table_) {}
-  __table_.__rehash_unique(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 @@ -534,10 +531,7 @@ hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(
 }
 template <class _Value, class _Hash, class _Pred, class _Alloc>
-hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(const hash_multiset& __u) : __table_(__u.__table_) {
+hash_multiset<_Value, _Hash, _Pred, _Alloc>::hash_multiset(const hash_multiset& __u) : __table_(__u.__table_) {}
-  __table_.__rehash_multi(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>

lib/libcxx/include/fenv.h+43-43

...	@@ -50,69 +50,69 @@ int feupdateenv(const fenv_t* envp);	...	@@ -50,69 +50,69 @@ int feupdateenv(const fenv_t* envp);
50	*/	50	*/
51		51
52	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	52	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
53	# include <__cxx03/fenv.h>	53	# include <__cxx03/__config>
54	#else	54	#else
55	# include <__config>	55	# include <__config>
		56	#endif
56		57
57	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	58	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
58	# pragma GCC system_header	59	# pragma GCC system_header
59	# endif	60	#endif
60		61
61	# if __has_include_next(<fenv.h>)	62	#if __has_include_next(<fenv.h>)
62	# include_next <fenv.h>	63	# include_next <fenv.h>
63	# endif	64	#endif
64		65
65	# ifdef __cplusplus	66	#ifdef __cplusplus
66		67
67	extern "C++" {	68	extern "C++" {
68		69
69	# ifdef feclearexcept	70	# ifdef feclearexcept
70	# undef feclearexcept	71	# undef feclearexcept
71	# endif	72	# endif
72		73
73	# ifdef fegetexceptflag	74	# ifdef fegetexceptflag
74	# undef fegetexceptflag	75	# undef fegetexceptflag
75	# endif	76	# endif
76		77
77	# ifdef feraiseexcept	78	# ifdef feraiseexcept
78	# undef feraiseexcept	79	# undef feraiseexcept
79	# endif	80	# endif
80		81
81	# ifdef fesetexceptflag	82	# ifdef fesetexceptflag
82	# undef fesetexceptflag	83	# undef fesetexceptflag
83	# endif	84	# endif
84		85
85	# ifdef fetestexcept	86	# ifdef fetestexcept
86	# undef fetestexcept	87	# undef fetestexcept
87	# endif	88	# endif
88		89
89	# ifdef fegetround	90	# ifdef fegetround
90	# undef fegetround	91	# undef fegetround
91	# endif	92	# endif
92		93
93	# ifdef fesetround	94	# ifdef fesetround
94	# undef fesetround	95	# undef fesetround
95	# endif	96	# endif
96		97
97	# ifdef fegetenv	98	# ifdef fegetenv
98	# undef fegetenv	99	# undef fegetenv
99	# endif	100	# endif
100		101
101	# ifdef feholdexcept	102	# ifdef feholdexcept
102	# undef feholdexcept	103	# undef feholdexcept
103	# endif	104	# endif
104		105
105	# ifdef fesetenv	106	# ifdef fesetenv
106	# undef fesetenv	107	# undef fesetenv
107	# endif	108	# endif
108		109
109	# ifdef feupdateenv	110	# ifdef feupdateenv
110	# undef feupdateenv	111	# undef feupdateenv
111	# endif	112	# endif
112		113
113	} // extern "C++"	114	} // extern "C++"
114		115
115	# endif // defined(__cplusplus)	116	#endif // defined(__cplusplus)
116	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
117		117
118	#endif // _LIBCPP_FENV_H	118	#endif // _LIBCPP_FENV_H

lib/libcxx/include/flat_map+663-11

...	@@ -17,18 +17,359 @@	...	@@ -17,18 +17,359 @@
17	#include <initializer_list> // see [initializer.list.syn]	17	#include <initializer_list> // see [initializer.list.syn]
18		18
19	namespace std {	19	namespace std {
		20	struct sorted_unique_t { explicit sorted_unique_t() = default; };
		21	inline constexpr sorted_unique_t sorted_unique{};
		22
20	// [flat.map], class template flat_map	23	// [flat.map], class template flat_map
21	template<class Key, class T, class Compare = less<Key>,	24	template<class Key, class T, class Compare = less<Key>,
22	class KeyContainer = vector<Key>, class MappedContainer = vector<T>>	25	class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
23	class flat_map;	26	class flat_map {
		27	public:
		28	// types
		29	using key_type = Key;
		30	using mapped_type = T;
		31	using value_type = pair<key_type, mapped_type>;
		32	using key_compare = Compare;
		33	using reference = pair<const key_type&, mapped_type&>;
		34	using const_reference = pair<const key_type&, const mapped_type&>;
		35	using size_type = size_t;
		36	using difference_type = ptrdiff_t;
		37	using iterator = implementation-defined; // see [container.requirements]
		38	using const_iterator = implementation-defined; // see [container.requirements]
		39	using reverse_iterator = std::reverse_iterator<iterator>;
		40	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
		41	using key_container_type = KeyContainer;
		42	using mapped_container_type = MappedContainer;
24		43
25	struct sorted_unique_t { explicit sorted_unique_t() = default; };	44	class value_compare {
26	inline constexpr sorted_unique_t sorted_unique{};	45	private:
		46	key_compare comp; // exposition only
		47	constexpr value_compare(key_compare c) : comp(c) { } // exposition only
		48
		49	public:
		50	constexpr bool operator()(const_reference x, const_reference y) const {
		51	return comp(x.first, y.first);
		52	}
		53	};
		54
		55	struct containers {
		56	key_container_type keys;
		57	mapped_container_type values;
		58	};
		59
		60	// [flat.map.cons], constructors
		61	constexpr flat_map() : flat_map(key_compare()) { }
		62
		63	constexpr flat_map(const flat_map&);
		64	constexpr flat_map(flat_map&&);
		65	constexpr flat_map& operator=(const flat_map&);
		66	constexpr flat_map& operator=(flat_map&&);
		67
		68	constexpr explicit flat_map(const key_compare& comp)
		69	: c(), compare(comp) { }
		70
		71	constexpr flat_map(key_container_type key_cont, mapped_container_type mapped_cont,
		72	const key_compare& comp = key_compare());
		73
		74	constexpr flat_map(sorted_unique_t, key_container_type key_cont,
		75	mapped_container_type mapped_cont,
		76	const key_compare& comp = key_compare());
		77
		78	template<class InputIterator>
		79	constexpr flat_map(InputIterator first, InputIterator last,
		80	const key_compare& comp = key_compare())
		81	: c(), compare(comp) { insert(first, last); }
		82
		83	template<class InputIterator>
		84	constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
		85	const key_compare& comp = key_compare())
		86	: c(), compare(comp) { insert(sorted_unique, first, last); }
		87
		88	template<container-compatible-range<value_type> R>
		89	constexpr flat_map(from_range_t, R&& rg)
		90	: flat_map(from_range, std::forward<R>(rg), key_compare()) { }
		91	template<container-compatible-range<value_type> R>
		92	constexpr flat_map(from_range_t, R&& rg, const key_compare& comp)
		93	: flat_map(comp) { insert_range(std::forward<R>(rg)); }
		94
		95	constexpr flat_map(initializer_list<value_type> il, const key_compare& comp = key_compare())
		96	: flat_map(il.begin(), il.end(), comp) { }
		97
		98	constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
		99	const key_compare& comp = key_compare())
		100	: flat_map(sorted_unique, il.begin(), il.end(), comp) { }
		101
		102	// [flat.map.cons.alloc], constructors with allocators
		103
		104	template<class Alloc>
		105	constexpr explicit flat_map(const Alloc& a);
		106	template<class Alloc>
		107	constexpr flat_map(const key_compare& comp, const Alloc& a);
		108	template<class Alloc>
		109	constexpr flat_map(const key_container_type& key_cont,
		110	const mapped_container_type& mapped_cont,
		111	const Alloc& a);
		112	template<class Alloc>
		113	constexpr flat_map(const key_container_type& key_cont,
		114	const mapped_container_type& mapped_cont,
		115	const key_compare& comp, const Alloc& a);
		116	template<class Alloc>
		117	constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
		118	const mapped_container_type& mapped_cont, const Alloc& a);
		119	template<class Alloc>
		120	constexpr flat_map(sorted_unique_t, const key_container_type& key_cont,
		121	const mapped_container_type& mapped_cont, const key_compare& comp,
		122	const Alloc& a);
		123	template<class Alloc>
		124	constexpr flat_map(const flat_map&, const Alloc& a);
		125	template<class Alloc>
		126	constexpr flat_map(flat_map&&, const Alloc& a);
		127	template<class InputIterator, class Alloc>
		128	constexpr flat_map(InputIterator first, InputIterator last, const Alloc& a);
		129	template<class InputIterator, class Alloc>
		130	constexpr flat_map(InputIterator first, InputIterator last,
		131	const key_compare& comp, const Alloc& a);
		132	template<class InputIterator, class Alloc>
		133	constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
		134	const Alloc& a);
		135	template<class InputIterator, class Alloc>
		136	constexpr flat_map(sorted_unique_t, InputIterator first, InputIterator last,
		137	const key_compare& comp, const Alloc& a);
		138	template<container-compatible-range<value_type> R, class Alloc>
		139	constexpr flat_map(from_range_t, R&& rg, const Alloc& a);
		140	template<container-compatible-range<value_type> R, class Alloc>
		141	constexpr flat_map(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
		142	template<class Alloc>
		143	constexpr flat_map(initializer_list<value_type> il, const Alloc& a);
		144	template<class Alloc>
		145	constexpr flat_map(initializer_list<value_type> il, const key_compare& comp,
		146	const Alloc& a);
		147	template<class Alloc>
		148	constexpr flat_map(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
		149	template<class Alloc>
		150	constexpr flat_map(sorted_unique_t, initializer_list<value_type> il,
		151	const key_compare& comp, const Alloc& a);
		152
		153	constexpr flat_map& operator=(initializer_list<value_type>);
		154
		155	// iterators
		156	constexpr iterator begin() noexcept;
		157	constexpr const_iterator begin() const noexcept;
		158	constexpr iterator end() noexcept;
		159	constexpr const_iterator end() const noexcept;
		160
		161	constexpr reverse_iterator rbegin() noexcept;
		162	constexpr const_reverse_iterator rbegin() const noexcept;
		163	constexpr reverse_iterator rend() noexcept;
		164	constexpr const_reverse_iterator rend() const noexcept;
		165
		166	constexpr const_iterator cbegin() const noexcept;
		167	constexpr const_iterator cend() const noexcept;
		168	constexpr const_reverse_iterator crbegin() const noexcept;
		169	constexpr const_reverse_iterator crend() const noexcept;
		170
		171	// [flat.map.capacity], capacity
		172	constexpr bool empty() const noexcept;
		173	constexpr size_type size() const noexcept;
		174	constexpr size_type max_size() const noexcept;
		175
		176	// [flat.map.access], element access
		177	constexpr mapped_type& operator[](const key_type& x);
		178	constexpr mapped_type& operator[](key_type&& x);
		179	template<class K> constexpr mapped_type& operator[](K&& x);
		180	constexpr mapped_type& at(const key_type& x);
		181	constexpr const mapped_type& at(const key_type& x) const;
		182	template<class K> constexpr mapped_type& at(const K& x);
		183	template<class K> constexpr const mapped_type& at(const K& x) const;
		184
		185	// [flat.map.modifiers], modifiers
		186	template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
		187	template<class... Args>
		188	constexpr iterator emplace_hint(const_iterator position, Args&&... args);
		189
		190	constexpr pair<iterator, bool> insert(const value_type& x)
		191	{ return emplace(x); }
		192	constexpr pair<iterator, bool> insert(value_type&& x)
		193	{ return emplace(std::move(x)); }
		194	constexpr iterator insert(const_iterator position, const value_type& x)
		195	{ return emplace_hint(position, x); }
		196	constexpr iterator insert(const_iterator position, value_type&& x)
		197	{ return emplace_hint(position, std::move(x)); }
		198
		199	template<class P> constexpr pair<iterator, bool> insert(P&& x);
		200	template<class P>
		201	constexpr iterator insert(const_iterator position, P&&);
		202	template<class InputIterator>
		203	constexpr void insert(InputIterator first, InputIterator last);
		204	template<class InputIterator>
		205	constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
		206	template<container-compatible-range<value_type> R>
		207	constexpr void insert_range(R&& rg);
		208	template<container-compatible-range<value_type> R>
		209	constexpr void insert_range(sorted_unique_t, R&& rg);
		210
		211	constexpr void insert(initializer_list<value_type> il)
		212	{ insert(il.begin(), il.end()); }
		213	constexpr void insert(sorted_unique_t, initializer_list<value_type> il)
		214	{ insert(sorted_unique, il.begin(), il.end()); }
		215
		216	constexpr containers extract() &&;
		217	constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
		218
		219	template<class... Args>
		220	constexpr pair<iterator, bool> try_emplace(const key_type& k, Args&&... args);
		221	template<class... Args>
		222	constexpr pair<iterator, bool> try_emplace(key_type&& k, Args&&... args);
		223	template<class K, class... Args>
		224	constexpr pair<iterator, bool> try_emplace(K&& k, Args&&... args);
		225	template<class... Args>
		226	constexpr iterator try_emplace(const_iterator hint, const key_type& k, Args&&... args);
		227	template<class... Args>
		228	constexpr iterator try_emplace(const_iterator hint, key_type&& k, Args&&... args);
		229	template<class K, class... Args>
		230	constexpr iterator try_emplace(const_iterator hint, K&& k, Args&&... args);
		231	template<class M>
		232	constexpr pair<iterator, bool> insert_or_assign(const key_type& k, M&& obj);
		233	template<class M>
		234	constexpr pair<iterator, bool> insert_or_assign(key_type&& k, M&& obj);
		235	template<class K, class M>
		236	constexpr pair<iterator, bool> insert_or_assign(K&& k, M&& obj);
		237	template<class M>
		238	constexpr iterator insert_or_assign(const_iterator hint, const key_type& k, M&& obj);
		239	template<class M>
		240	constexpr iterator insert_or_assign(const_iterator hint, key_type&& k, M&& obj);
		241	template<class K, class M>
		242	constexpr iterator insert_or_assign(const_iterator hint, K&& k, M&& obj);
		243
		244	constexpr iterator erase(iterator position);
		245	constexpr iterator erase(const_iterator position);
		246	constexpr size_type erase(const key_type& x);
		247	template<class K> constexpr size_type erase(K&& x);
		248	constexpr iterator erase(const_iterator first, const_iterator last);
		249
		250	constexpr void swap(flat_map& y) noexcept(see below);
		251	constexpr void clear() noexcept;
		252
		253	// observers
		254	constexpr key_compare key_comp() const;
		255	constexpr value_compare value_comp() const;
		256
		257	constexpr const key_container_type& keys() const noexcept { return c.keys; }
		258	constexpr const mapped_container_type& values() const noexcept { return c.values; }
		259
		260	// map operations
		261	constexpr iterator find(const key_type& x);
		262	constexpr const_iterator find(const key_type& x) const;
		263	template<class K> constexpr iterator find(const K& x);
		264	template<class K> constexpr const_iterator find(const K& x) const;
		265
		266	constexpr size_type count(const key_type& x) const;
		267	template<class K> constexpr size_type count(const K& x) const;
		268
		269	constexpr bool contains(const key_type& x) const;
		270	template<class K> constexpr bool contains(const K& x) const;
		271
		272	constexpr iterator lower_bound(const key_type& x);
		273	constexpr const_iterator lower_bound(const key_type& x) const;
		274	template<class K> constexpr iterator lower_bound(const K& x);
		275	template<class K> constexpr const_iterator lower_bound(const K& x) const;
		276
		277	constexpr iterator upper_bound(const key_type& x);
		278	constexpr const_iterator upper_bound(const key_type& x) const;
		279	template<class K> constexpr iterator upper_bound(const K& x);
		280	template<class K> constexpr const_iterator upper_bound(const K& x) const;
		281
		282	constexpr pair<iterator, iterator> equal_range(const key_type& x);
		283	constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
		284	template<class K> constexpr pair<iterator, iterator> equal_range(const K& x);
		285	template<class K>
		286	constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
		287
		288	friend constexpr bool operator==(const flat_map& x, const flat_map& y);
		289
		290	friend constexpr synth-three-way-result<value_type>
		291	operator<=>(const flat_map& x, const flat_map& y);
		292
		293	friend constexpr void swap(flat_map& x, flat_map& y) noexcept(noexcept(x.swap(y)))
		294	{ x.swap(y); }
		295
		296	private:
		297	containers c; // exposition only
		298	key_compare compare; // exposition only
		299
		300	struct key-equiv { // exposition only
		301	constexpr key-equiv(key_compare c) : comp(c) { }
		302	constexpr bool operator()(const_reference x, const_reference y) const {
		303	return !comp(x.first, y.first) && !comp(y.first, x.first);
		304	}
		305	key_compare comp;
		306	};
		307	};
		308
		309	template<class KeyContainer, class MappedContainer,
		310	class Compare = less<typename KeyContainer::value_type>>
		311	flat_map(KeyContainer, MappedContainer, Compare = Compare())
		312	-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
		313	Compare, KeyContainer, MappedContainer>;
		314
		315	template<class KeyContainer, class MappedContainer, class Allocator>
		316	flat_map(KeyContainer, MappedContainer, Allocator)
		317	-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
		318	less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
		319	template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
		320	flat_map(KeyContainer, MappedContainer, Compare, Allocator)
		321	-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
		322	Compare, KeyContainer, MappedContainer>;
		323
		324	template<class KeyContainer, class MappedContainer,
		325	class Compare = less<typename KeyContainer::value_type>>
		326	flat_map(sorted_unique_t, KeyContainer, MappedContainer, Compare = Compare())
		327	-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
		328	Compare, KeyContainer, MappedContainer>;
		329
		330	template<class KeyContainer, class MappedContainer, class Allocator>
		331	flat_map(sorted_unique_t, KeyContainer, MappedContainer, Allocator)
		332	-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
		333	less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
		334	template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
		335	flat_map(sorted_unique_t, KeyContainer, MappedContainer, Compare, Allocator)
		336	-> flat_map<typename KeyContainer::value_type, typename MappedContainer::value_type,
		337	Compare, KeyContainer, MappedContainer>;
		338
		339	template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
		340	flat_map(InputIterator, InputIterator, Compare = Compare())
		341	-> flat_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
		342
		343	template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
		344	flat_map(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
		345	-> flat_map<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
		346
		347	template<ranges::input_range R, class Compare = less<range-key-type<R>>,
		348	class Allocator = allocator<byte>>
		349	flat_map(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
		350	-> flat_map<range-key-type<R>, range-mapped-type<R>, Compare,
		351	vector<range-key-type<R>, alloc-rebind<Allocator, range-key-type<R>>>,
		352	vector<range-mapped-type<R>, alloc-rebind<Allocator, range-mapped-type<R>>>>;
		353
		354	template<ranges::input_range R, class Allocator>
		355	flat_map(from_range_t, R&&, Allocator)
		356	-> flat_map<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>,
		357	vector<range-key-type<R>, alloc-rebind<Allocator, range-key-type<R>>>,
		358	vector<range-mapped-type<R>, alloc-rebind<Allocator, range-mapped-type<R>>>>;
		359
		360	template<class Key, class T, class Compare = less<Key>>
		361	flat_map(initializer_list<pair<Key, T>>, Compare = Compare())
		362	-> flat_map<Key, T, Compare>;
		363
		364	template<class Key, class T, class Compare = less<Key>>
		365	flat_map(sorted_unique_t, initializer_list<pair<Key, T>>, Compare = Compare())
		366	-> flat_map<Key, T, Compare>;
27		367
28	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,	368	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
29	class Allocator>	369	class Allocator>
30	struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>,	370	struct uses_allocator<flat_map<Key, T, Compare, KeyContainer, MappedContainer>, Allocator>
31	Allocator>;	371	: bool_constant<uses_allocator_v<KeyContainer, Allocator> &&
		372	uses_allocator_v<MappedContainer, Allocator>> { };
32		373
33	// [flat.map.erasure], erasure for flat_map	374	// [flat.map.erasure], erasure for flat_map
34	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,	375	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
...	@@ -36,18 +377,329 @@ namespace std {	...	@@ -36,18 +377,329 @@ namespace std {
36	typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type	377	typename flat_map<Key, T, Compare, KeyContainer, MappedContainer>::size_type
37	erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);	378	erase_if(flat_map<Key, T, Compare, KeyContainer, MappedContainer>& c, Predicate pred);
38		379
		380	struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
		381	inline constexpr sorted_equivalent_t sorted_equivalent{};
		382
39	// [flat.multimap], class template flat_multimap	383	// [flat.multimap], class template flat_multimap
40	template<class Key, class T, class Compare = less<Key>,	384	template<class Key, class T, class Compare = less<Key>,
41	class KeyContainer = vector<Key>, class MappedContainer = vector<T>>	385	class KeyContainer = vector<Key>, class MappedContainer = vector<T>>
42	class flat_multimap;	386	class flat_multimap {
		387	public:
		388	// types
		389	using key_type = Key;
		390	using mapped_type = T;
		391	using value_type = pair<key_type, mapped_type>;
		392	using key_compare = Compare;
		393	using reference = pair<const key_type&, mapped_type&>;
		394	using const_reference = pair<const key_type&, const mapped_type&>;
		395	using size_type = size_t;
		396	using difference_type = ptrdiff_t;
		397	using iterator = implementation-defined; // see [container.requirements]
		398	using const_iterator = implementation-defined; // see [container.requirements]
		399	using reverse_iterator = std::reverse_iterator<iterator>;
		400	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
		401	using key_container_type = KeyContainer;
		402	using mapped_container_type = MappedContainer;
43		403
44	struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };	404	class value_compare {
45	inline constexpr sorted_equivalent_t sorted_equivalent{};	405	private:
		406	key_compare comp; // exposition only
		407	constexpr value_compare(key_compare c) : comp(c) { } // exposition only
		408
		409	public:
		410	constexpr bool operator()(const_reference x, const_reference y) const {
		411	return comp(x.first, y.first);
		412	}
		413	};
		414
		415	struct containers {
		416	key_container_type keys;
		417	mapped_container_type values;
		418	};
		419
		420	// [flat.multimap.cons], constructors
		421	constexpr flat_multimap() : flat_multimap(key_compare()) { }
		422
		423	constexpr flat_multimap(const flat_multimap&);
		424	constexpr flat_multimap(flat_multimap&&);
		425	constexpr flat_multimap& operator=(const flat_multimap&);
		426	constexpr flat_multimap& operator=(flat_multimap&&);
		427
		428	constexpr explicit flat_multimap(const key_compare& comp)
		429	: c(), compare(comp) { }
		430
		431	constexpr flat_multimap(key_container_type key_cont, mapped_container_type mapped_cont,
		432	const key_compare& comp = key_compare());
		433
		434	constexpr flat_multimap(sorted_equivalent_t,
		435	key_container_type key_cont, mapped_container_type mapped_cont,
		436	const key_compare& comp = key_compare());
		437
		438	template<class InputIterator>
		439	constexpr flat_multimap(InputIterator first, InputIterator last,
		440	const key_compare& comp = key_compare())
		441	: c(), compare(comp)
		442	{ insert(first, last); }
		443
		444	template<class InputIterator>
		445	constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
		446	const key_compare& comp = key_compare())
		447	: c(), compare(comp) { insert(sorted_equivalent, first, last); }
		448
		449	template<container-compatible-range<value_type> R>
		450	constexpr flat_multimap(from_range_t, R&& rg)
		451	: flat_multimap(from_range, std::forward<R>(rg), key_compare()) { }
		452	template<container-compatible-range<value_type> R>
		453	constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp)
		454	: flat_multimap(comp) { insert_range(std::forward<R>(rg)); }
		455
		456	constexpr flat_multimap(initializer_list<value_type> il,
		457	const key_compare& comp = key_compare())
		458	: flat_multimap(il.begin(), il.end(), comp) { }
		459
		460	constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
		461	const key_compare& comp = key_compare())
		462	: flat_multimap(sorted_equivalent, il.begin(), il.end(), comp) { }
		463
		464	// [flat.multimap.cons.alloc], constructors with allocators
		465
		466	template<class Alloc>
		467	constexpr explicit flat_multimap(const Alloc& a);
		468	template<class Alloc>
		469	constexpr flat_multimap(const key_compare& comp, const Alloc& a);
		470	template<class Alloc>
		471	constexpr flat_multimap(const key_container_type& key_cont,
		472	const mapped_container_type& mapped_cont, const Alloc& a);
		473	template<class Alloc>
		474	constexpr flat_multimap(const key_container_type& key_cont,
		475	const mapped_container_type& mapped_cont,
		476	const key_compare& comp, const Alloc& a);
		477	template<class Alloc>
		478	constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
		479	const mapped_container_type& mapped_cont, const Alloc& a);
		480	template<class Alloc>
		481	constexpr flat_multimap(sorted_equivalent_t, const key_container_type& key_cont,
		482	const mapped_container_type& mapped_cont,
		483	const key_compare& comp, const Alloc& a);
		484	template<class Alloc>
		485	constexpr flat_multimap(const flat_multimap&, const Alloc& a);
		486	template<class Alloc>
		487	constexpr flat_multimap(flat_multimap&&, const Alloc& a);
		488	template<class InputIterator, class Alloc>
		489	constexpr flat_multimap(InputIterator first, InputIterator last, const Alloc& a);
		490	template<class InputIterator, class Alloc>
		491	constexpr flat_multimap(InputIterator first, InputIterator last,
		492	const key_compare& comp, const Alloc& a);
		493	template<class InputIterator, class Alloc>
		494	constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
		495	const Alloc& a);
		496	template<class InputIterator, class Alloc>
		497	constexpr flat_multimap(sorted_equivalent_t, InputIterator first, InputIterator last,
		498	const key_compare& comp, const Alloc& a);
		499	template<container-compatible-range<value_type> R, class Alloc>
		500	constexpr flat_multimap(from_range_t, R&& rg, const Alloc& a);
		501	template<container-compatible-range<value_type> R, class Alloc>
		502	constexpr flat_multimap(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
		503	template<class Alloc>
		504	constexpr flat_multimap(initializer_list<value_type> il, const Alloc& a);
		505	template<class Alloc>
		506	constexpr flat_multimap(initializer_list<value_type> il, const key_compare& comp,
		507	const Alloc& a);
		508	template<class Alloc>
		509	constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
		510	const Alloc& a);
		511	template<class Alloc>
		512	constexpr flat_multimap(sorted_equivalent_t, initializer_list<value_type> il,
		513	const key_compare& comp, const Alloc& a);
		514
		515	flat_multimap& operator=(initializer_list<value_type>);
		516
		517	// iterators
		518	constexpr iterator begin() noexcept;
		519	constexpr const_iterator begin() const noexcept;
		520	constexpr iterator end() noexcept;
		521	constexpr const_iterator end() const noexcept;
		522
		523	constexpr reverse_iterator rbegin() noexcept;
		524	constexpr const_reverse_iterator rbegin() const noexcept;
		525	constexpr reverse_iterator rend() noexcept;
		526	constexpr const_reverse_iterator rend() const noexcept;
		527
		528	constexpr const_iterator cbegin() const noexcept;
		529	constexpr const_iterator cend() const noexcept;
		530	constexpr const_reverse_iterator crbegin() const noexcept;
		531	constexpr const_reverse_iterator crend() const noexcept;
		532
		533	// capacity
		534	constexpr bool empty() const noexcept;
		535	constexpr size_type size() const noexcept;
		536	constexpr size_type max_size() const noexcept;
		537
		538	// modifiers
		539	template<class... Args> constexpr iterator emplace(Args&&... args);
		540	template<class... Args>
		541	constexpr iterator emplace_hint(const_iterator position, Args&&... args);
		542
		543	constexpr iterator insert(const value_type& x)
		544	{ return emplace(x); }
		545	constexpr iterator insert(value_type&& x)
		546	{ return emplace(std::move(x)); }
		547	constexpr iterator insert(const_iterator position, const value_type& x)
		548	{ return emplace_hint(position, x); }
		549	constexpr iterator insert(const_iterator position, value_type&& x)
		550	{ return emplace_hint(position, std::move(x)); }
		551
		552	template<class P> constexpr iterator insert(P&& x);
		553	template<class P>
		554	constexpr iterator insert(const_iterator position, P&&);
		555	template<class InputIterator>
		556	constexpr void insert(InputIterator first, InputIterator last);
		557	template<class InputIterator>
		558	constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
		559	template<container-compatible-range<value_type> R>
		560	constexpr void insert_range(R&& rg);
		561	template<container-compatible-range<value_type> R>
		562	constexpr void insert_range(sorted_equivalent_t, R&& rg);
		563
		564	constexpr void insert(initializer_list<value_type> il)
		565	{ insert(il.begin(), il.end()); }
		566	constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
		567	{ insert(sorted_equivalent, il.begin(), il.end()); }
		568
		569	constexpr containers extract() &&;
		570	constexpr void replace(key_container_type&& key_cont, mapped_container_type&& mapped_cont);
		571
		572	constexpr iterator erase(iterator position);
		573	constexpr iterator erase(const_iterator position);
		574	constexpr size_type erase(const key_type& x);
		575	template<class K> constexpr size_type erase(K&& x);
		576	constexpr iterator erase(const_iterator first, const_iterator last);
		577
		578	constexpr void swap(flat_multimap&)
		579	noexcept(is_nothrow_swappable_v<key_container_type> &&
		580	is_nothrow_swappable_v<mapped_container_type> &&
		581	is_nothrow_swappable_v<key_compare>);
		582	constexpr void clear() noexcept;
		583
		584	// observers
		585	constexpr key_compare key_comp() const;
		586	constexpr value_compare value_comp() const;
		587
		588	constexpr const key_container_type& keys() const noexcept { return c.keys; }
		589	constexpr const mapped_container_type& values() const noexcept { return c.values; }
		590
		591	// map operations
		592	constexpr iterator find(const key_type& x);
		593	constexpr const_iterator find(const key_type& x) const;
		594	template<class K> constexpr iterator find(const K& x);
		595	template<class K> constexpr const_iterator find(const K& x) const;
		596
		597	constexpr size_type count(const key_type& x) const;
		598	template<class K> constexpr size_type count(const K& x) const;
		599
		600	constexpr bool contains(const key_type& x) const;
		601	template<class K> constexpr bool contains(const K& x) const;
		602
		603	constexpr iterator lower_bound(const key_type& x);
		604	constexpr const_iterator lower_bound(const key_type& x) const;
		605	template<class K> constexpr iterator lower_bound(const K& x);
		606	template<class K> constexpr const_iterator lower_bound(const K& x) const;
		607
		608	constexpr iterator upper_bound(const key_type& x);
		609	constexpr const_iterator upper_bound(const key_type& x) const;
		610	template<class K> constexpr iterator upper_bound(const K& x);
		611	template<class K> constexpr const_iterator upper_bound(const K& x) const;
		612
		613	constexpr pair<iterator, iterator> equal_range(const key_type& x);
		614	constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
		615	template<class K>
		616	constexpr pair<iterator, iterator> equal_range(const K& x);
		617	template<class K>
		618	constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
		619
		620	friend constexpr bool operator==(const flat_multimap& x, const flat_multimap& y);
		621
		622	friend constexpr synth-three-way-result<value_type>
		623	operator<=>(const flat_multimap& x, const flat_multimap& y);
		624
		625	friend constexpr void swap(flat_multimap& x, flat_multimap& y)
		626	noexcept(noexcept(x.swap(y)))
		627	{ x.swap(y); }
		628
		629	private:
		630	containers c; // exposition only
		631	key_compare compare; // exposition only
		632	};
		633
		634	template<class KeyContainer, class MappedContainer,
		635	class Compare = less<typename KeyContainer::value_type>>
		636	flat_multimap(KeyContainer, MappedContainer, Compare = Compare())
		637	-> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
		638	Compare, KeyContainer, MappedContainer>;
		639
		640	template<class KeyContainer, class MappedContainer, class Allocator>
		641	flat_multimap(KeyContainer, MappedContainer, Allocator)
		642	-> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
		643	less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
		644	template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
		645	flat_multimap(KeyContainer, MappedContainer, Compare, Allocator)
		646	-> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
		647	Compare, KeyContainer, MappedContainer>;
		648
		649	template<class KeyContainer, class MappedContainer,
		650	class Compare = less<typename KeyContainer::value_type>>
		651	flat_multimap(sorted_equivalent_t, KeyContainer, MappedContainer, Compare = Compare())
		652	-> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
		653	Compare, KeyContainer, MappedContainer>;
		654
		655	template<class KeyContainer, class MappedContainer, class Allocator>
		656	flat_multimap(sorted_equivalent_t, KeyContainer, MappedContainer, Allocator)
		657	-> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
		658	less<typename KeyContainer::value_type>, KeyContainer, MappedContainer>;
		659	template<class KeyContainer, class MappedContainer, class Compare, class Allocator>
		660	flat_multimap(sorted_equivalent_t, KeyContainer, MappedContainer, Compare, Allocator)
		661	-> flat_multimap<typename KeyContainer::value_type, typename MappedContainer::value_type,
		662	Compare, KeyContainer, MappedContainer>;
		663
		664	template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
		665	flat_multimap(InputIterator, InputIterator, Compare = Compare())
		666	-> flat_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
		667
		668	template<class InputIterator, class Compare = less<iter-key-type<InputIterator>>>
		669	flat_multimap(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
		670	-> flat_multimap<iter-key-type<InputIterator>, iter-mapped-type<InputIterator>, Compare>;
		671
		672	template<ranges::input_range R, class Compare = less<range-key-type<R>>,
		673	class Allocator = allocator<byte>>
		674	flat_multimap(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
		675	-> flat_multimap<range-key-type<R>, range-mapped-type<R>, Compare,
		676	vector<range-key-type<R>,
		677	alloc-rebind<Allocator, range-key-type<R>>>,
		678	vector<range-mapped-type<R>,
		679	alloc-rebind<Allocator, range-mapped-type<R>>>>;
		680
		681	template<ranges::input_range R, class Allocator>
		682	flat_multimap(from_range_t, R&&, Allocator)
		683	-> flat_multimap<range-key-type<R>, range-mapped-type<R>, less<range-key-type<R>>,
		684	vector<range-key-type<R>,
		685	alloc-rebind<Allocator, range-key-type<R>>>,
		686	vector<range-mapped-type<R>,
		687	alloc-rebind<Allocator, range-mapped-type<R>>>>;
		688
		689	template<class Key, class T, class Compare = less<Key>>
		690	flat_multimap(initializer_list<pair<Key, T>>, Compare = Compare())
		691	-> flat_multimap<Key, T, Compare>;
		692
		693	template<class Key, class T, class Compare = less<Key>>
		694	flat_multimap(sorted_equivalent_t, initializer_list<pair<Key, T>>, Compare = Compare())
		695	-> flat_multimap<Key, T, Compare>;
46		696
47	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,	697	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,
48	class Allocator>	698	class Allocator>
49	struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,	699	struct uses_allocator<flat_multimap<Key, T, Compare, KeyContainer, MappedContainer>,
50	Allocator>;	700	Allocator>
		701	: bool_constant<uses_allocator_v<KeyContainer, Allocator> &&
		702	uses_allocator_v<MappedContainer, Allocator>> { };
51		703
52	// [flat.multimap.erasure], erasure for flat_multimap	704	// [flat.multimap.erasure], erasure for flat_multimap
53	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,	705	template<class Key, class T, class Compare, class KeyContainer, class MappedContainer,

lib/libcxx/include/flat_set+543-8

...	@@ -17,30 +17,565 @@	...	@@ -17,30 +17,565 @@
17	#include <initializer_list> // see [initializer.list.syn]	17	#include <initializer_list> // see [initializer.list.syn]
18		18
19	namespace std {	19	namespace std {
		20	struct sorted_unique_t { explicit sorted_unique_t() = default; };
		21	inline constexpr sorted_unique_t sorted_unique{};
		22
20	// [flat.set], class template flat_set	23	// [flat.set], class template flat_set
21	template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>	24	template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
22	class flat_set;	25	class flat_set {
		26	public:
		27	// types
		28	using key_type = Key;
		29	using value_type = Key;
		30	using key_compare = Compare;
		31	using value_compare = Compare;
		32	using reference = value_type&;
		33	using const_reference = const value_type&;
		34	using size_type = KeyContainer::size_type;
		35	using difference_type = KeyContainer::difference_type;
		36	using iterator = implementation-defined; // see [container.requirements]
		37	using const_iterator = implementation-defined; // see [container.requirements]
		38	using reverse_iterator = std::reverse_iterator<iterator>;
		39	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
		40	using container_type = KeyContainer;
23		41
24	struct sorted_unique_t { explicit sorted_unique_t() = default; };	42	// [flat.set.cons], constructors
25	inline constexpr sorted_unique_t sorted_unique{};	43	constexpr flat_set() : flat_set(key_compare()) { }
		44
		45	constexpr flat_set(const flat_set&);
		46	constexpr flat_set(flat_set&&);
		47	constexpr flat_set& operator=(const flat_set&);
		48	constexpr flat_set& operator=(flat_set&&);
		49
		50	constexpr explicit flat_set(const key_compare& comp)
		51	: c(), compare(comp) { }
		52
		53	constexpr explicit flat_set(container_type cont, const key_compare& comp = key_compare());
		54
		55	constexpr flat_set(sorted_unique_t, container_type cont,
		56	const key_compare& comp = key_compare())
		57	: c(std::move(cont)), compare(comp) { }
		58
		59	template<class InputIterator>
		60	constexpr flat_set(InputIterator first, InputIterator last,
		61	const key_compare& comp = key_compare())
		62	: c(), compare(comp)
		63	{ insert(first, last); }
		64
		65	template<class InputIterator>
		66	constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
		67	const key_compare& comp = key_compare())
		68	: c(first, last), compare(comp) { }
		69
		70	template<container-compatible-range<value_type> R>
		71	constexpr flat_set(from_range_t, R&& rg)
		72	: flat_set(from_range, std::forward<R>(rg), key_compare()) { }
		73	template<container-compatible-range<value_type> R>
		74	constexpr flat_set(from_range_t, R&& rg, const key_compare& comp)
		75	: flat_set(comp)
		76	{ insert_range(std::forward<R>(rg)); }
		77
		78	constexpr flat_set(initializer_list<value_type> il, const key_compare& comp = key_compare())
		79	: flat_set(il.begin(), il.end(), comp) { }
		80
		81	constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
		82	const key_compare& comp = key_compare())
		83	: flat_set(sorted_unique, il.begin(), il.end(), comp) { }
		84
		85	// [flat.set.cons.alloc], constructors with allocators
		86
		87	template<class Alloc>
		88	constexpr explicit flat_set(const Alloc& a);
		89	template<class Alloc>
		90	constexpr flat_set(const key_compare& comp, const Alloc& a);
		91	template<class Alloc>
		92	constexpr flat_set(const container_type& cont, const Alloc& a);
		93	template<class Alloc>
		94	constexpr flat_set(const container_type& cont, const key_compare& comp, const Alloc& a);
		95	template<class Alloc>
		96	constexpr flat_set(sorted_unique_t, const container_type& cont, const Alloc& a);
		97	template<class Alloc>
		98	constexpr flat_set(sorted_unique_t, const container_type& cont,
		99	const key_compare& comp, const Alloc& a);
		100	template<class Alloc>
		101	constexpr flat_set(const flat_set&, const Alloc& a);
		102	template<class Alloc>
		103	constexpr flat_set(flat_set&&, const Alloc& a);
		104	template<class InputIterator, class Alloc>
		105	constexpr flat_set(InputIterator first, InputIterator last, const Alloc& a);
		106	template<class InputIterator, class Alloc>
		107	constexpr flat_set(InputIterator first, InputIterator last,
		108	const key_compare& comp, const Alloc& a);
		109	template<class InputIterator, class Alloc>
		110	constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
		111	const Alloc& a);
		112	template<class InputIterator, class Alloc>
		113	constexpr flat_set(sorted_unique_t, InputIterator first, InputIterator last,
		114	const key_compare& comp, const Alloc& a);
		115	template<container-compatible-range<value_type> R, class Alloc>
		116	constexpr flat_set(from_range_t, R&& rg, const Alloc& a);
		117	template<container-compatible-range<value_type> R, class Alloc>
		118	constexpr flat_set(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
		119	template<class Alloc>
		120	constexpr flat_set(initializer_list<value_type> il, const Alloc& a);
		121	template<class Alloc>
		122	constexpr flat_set(initializer_list<value_type> il, const key_compare& comp,
		123	const Alloc& a);
		124	template<class Alloc>
		125	constexpr flat_set(sorted_unique_t, initializer_list<value_type> il, const Alloc& a);
		126	template<class Alloc>
		127	constexpr flat_set(sorted_unique_t, initializer_list<value_type> il,
		128	const key_compare& comp, const Alloc& a);
		129
		130	constexpr flat_set& operator=(initializer_list<value_type>);
		131
		132	// iterators
		133	constexpr iterator begin() noexcept;
		134	constexpr const_iterator begin() const noexcept;
		135	constexpr iterator end() noexcept;
		136	constexpr const_iterator end() const noexcept;
		137
		138	constexpr reverse_iterator rbegin() noexcept;
		139	constexpr const_reverse_iterator rbegin() const noexcept;
		140	constexpr reverse_iterator rend() noexcept;
		141	constexpr const_reverse_iterator rend() const noexcept;
		142
		143	constexpr const_iterator cbegin() const noexcept;
		144	constexpr const_iterator cend() const noexcept;
		145	constexpr const_reverse_iterator crbegin() const noexcept;
		146	constexpr const_reverse_iterator crend() const noexcept;
		147
		148	// capacity
		149	constexpr bool empty() const noexcept;
		150	constexpr size_type size() const noexcept;
		151	constexpr size_type max_size() const noexcept;
		152
		153	// [flat.set.modifiers], modifiers
		154	template<class... Args> constexpr pair<iterator, bool> emplace(Args&&... args);
		155	template<class... Args>
		156	constexpr iterator emplace_hint(const_iterator position, Args&&... args);
		157
		158	constexpr pair<iterator, bool> insert(const value_type& x)
		159	{ return emplace(x); }
		160	constexpr pair<iterator, bool> insert(value_type&& x)
		161	{ return emplace(std::move(x)); }
		162	template<class K> constexpr pair<iterator, bool> insert(K&& x);
		163	constexpr iterator insert(const_iterator position, const value_type& x)
		164	{ return emplace_hint(position, x); }
		165	constexpr iterator insert(const_iterator position, value_type&& x)
		166	{ return emplace_hint(position, std::move(x)); }
		167	template<class K> constexpr iterator insert(const_iterator hint, K&& x);
		168
		169	template<class InputIterator>
		170	constexpr void insert(InputIterator first, InputIterator last);
		171	template<class InputIterator>
		172	constexpr void insert(sorted_unique_t, InputIterator first, InputIterator last);
		173	template<container-compatible-range<value_type> R>
		174	constexpr void insert_range(R&& rg);
		175	template<container-compatible-range<value_type> R>
		176	constexpr void insert_range(sorted_unique_t, R&& rg);
		177
		178	constexpr void insert(initializer_list<value_type> il)
		179	{ insert(il.begin(), il.end()); }
		180	constexpr void insert(sorted_unique_t, initializer_list<value_type> il)
		181	{ insert(sorted_unique, il.begin(), il.end()); }
		182
		183	constexpr container_type extract() &&;
		184	constexpr void replace(container_type&&);
		185
		186	constexpr iterator erase(iterator position) requires (!same_as<iterator, const_iterator>);
		187	constexpr iterator erase(const_iterator position);
		188	constexpr size_type erase(const key_type& x);
		189	template<class K> constexpr size_type erase(K&& x);
		190	constexpr iterator erase(const_iterator first, const_iterator last);
		191
		192	constexpr void swap(flat_set& y) noexcept(see below);
		193	constexpr void clear() noexcept;
		194
		195	// observers
		196	constexpr key_compare key_comp() const;
		197	constexpr value_compare value_comp() const;
		198
		199	// set operations
		200	constexpr iterator find(const key_type& x);
		201	constexpr const_iterator find(const key_type& x) const;
		202	template<class K> constexpr iterator find(const K& x);
		203	template<class K> constexpr const_iterator find(const K& x) const;
		204
		205	constexpr size_type count(const key_type& x) const;
		206	template<class K> constexpr size_type count(const K& x) const;
		207
		208	constexpr bool contains(const key_type& x) const;
		209	template<class K> constexpr bool contains(const K& x) const;
		210
		211	constexpr iterator lower_bound(const key_type& x);
		212	constexpr const_iterator lower_bound(const key_type& x) const;
		213	template<class K> constexpr iterator lower_bound(const K& x);
		214	template<class K> constexpr const_iterator lower_bound(const K& x) const;
		215
		216	constexpr iterator upper_bound(const key_type& x);
		217	constexpr const_iterator upper_bound(const key_type& x) const;
		218	template<class K> constexpr iterator upper_bound(const K& x);
		219	template<class K> constexpr const_iterator upper_bound(const K& x) const;
		220
		221	constexpr pair<iterator, iterator> equal_range(const key_type& x);
		222	constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
		223	template<class K>
		224	constexpr pair<iterator, iterator> equal_range(const K& x);
		225	template<class K>
		226	constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
		227
		228	friend constexpr bool operator==(const flat_set& x, const flat_set& y);
		229
		230	friend constexpr synth-three-way-result<value_type>
		231	operator<=>(const flat_set& x, const flat_set& y);
		232
		233	friend constexpr void swap(flat_set& x, flat_set& y) noexcept(noexcept(x.swap(y)))
		234	{ x.swap(y); }
		235
		236	private:
		237	container_type c; // exposition only
		238	key_compare compare; // exposition only
		239	};
		240
		241	template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
		242	flat_set(KeyContainer, Compare = Compare())
		243	-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
		244	template<class KeyContainer, class Allocator>
		245	flat_set(KeyContainer, Allocator)
		246	-> flat_set<typename KeyContainer::value_type,
		247	less<typename KeyContainer::value_type>, KeyContainer>;
		248	template<class KeyContainer, class Compare, class Allocator>
		249	flat_set(KeyContainer, Compare, Allocator)
		250	-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
		251
		252	template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
		253	flat_set(sorted_unique_t, KeyContainer, Compare = Compare())
		254	-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
		255	template<class KeyContainer, class Allocator>
		256	flat_set(sorted_unique_t, KeyContainer, Allocator)
		257	-> flat_set<typename KeyContainer::value_type,
		258	less<typename KeyContainer::value_type>, KeyContainer>;
		259	template<class KeyContainer, class Compare, class Allocator>
		260	flat_set(sorted_unique_t, KeyContainer, Compare, Allocator)
		261	-> flat_set<typename KeyContainer::value_type, Compare, KeyContainer>;
		262
		263	template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
		264	flat_set(InputIterator, InputIterator, Compare = Compare())
		265	-> flat_set<iter-value-type<InputIterator>, Compare>;
		266
		267	template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
		268	flat_set(sorted_unique_t, InputIterator, InputIterator, Compare = Compare())
		269	-> flat_set<iter-value-type<InputIterator>, Compare>;
		270
		271	template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
		272	class Allocator = allocator<ranges::range_value_t<R>>>
		273	flat_set(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
		274	-> flat_set<ranges::range_value_t<R>, Compare,
		275	vector<ranges::range_value_t<R>,
		276	alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
		277
		278	template<ranges::input_range R, class Allocator>
		279	flat_set(from_range_t, R&&, Allocator)
		280	-> flat_set<ranges::range_value_t<R>, less<ranges::range_value_t<R>>,
		281	vector<ranges::range_value_t<R>,
		282	alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
		283
		284	template<class Key, class Compare = less<Key>>
		285	flat_set(initializer_list<Key>, Compare = Compare())
		286	-> flat_set<Key, Compare>;
		287
		288	template<class Key, class Compare = less<Key>>
		289	flat_set(sorted_unique_t, initializer_list<Key>, Compare = Compare())
		290	-> flat_set<Key, Compare>;
26		291
27	template<class Key, class Compare, class KeyContainer, class Allocator>	292	template<class Key, class Compare, class KeyContainer, class Allocator>
28	struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>;	293	struct uses_allocator<flat_set<Key, Compare, KeyContainer>, Allocator>
		294	: bool_constant<uses_allocator_v<KeyContainer, Allocator>> { };
29		295
30	// [flat.set.erasure], erasure for flat_set	296	// [flat.set.erasure], erasure for flat_set
31	template<class Key, class Compare, class KeyContainer, class Predicate>	297	template<class Key, class Compare, class KeyContainer, class Predicate>
32	typename flat_set<Key, Compare, KeyContainer>::size_type	298	typename flat_set<Key, Compare, KeyContainer>::size_type
33	erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);	299	erase_if(flat_set<Key, Compare, KeyContainer>& c, Predicate pred);
34		300
		301	struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };
		302	inline constexpr sorted_equivalent_t sorted_equivalent{};
		303
35	// [flat.multiset], class template flat_multiset	304	// [flat.multiset], class template flat_multiset
36	template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>	305	template<class Key, class Compare = less<Key>, class KeyContainer = vector<Key>>
37	class flat_multiset;	306	class flat_multiset {
		307	public:
		308	// types
		309	using key_type = Key;
		310	using value_type = Key;
		311	using key_compare = Compare;
		312	using value_compare = Compare;
		313	using reference = value_type&;
		314	using const_reference = const value_type&;
		315	using size_type = KeyContainer::size_type;
		316	using difference_type = KeyContainer::difference_type;
		317	using iterator = implementation-defined; // see [container.requirements]
		318	using const_iterator = implementation-defined; // see [container.requirements]
		319	using reverse_iterator = std::reverse_iterator<iterator>;
		320	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
		321	using container_type = KeyContainer;
38		322
39	struct sorted_equivalent_t { explicit sorted_equivalent_t() = default; };	323	// [flat.multiset.cons], constructors
40	inline constexpr sorted_equivalent_t sorted_equivalent{};	324	constexpr flat_multiset() : flat_multiset(key_compare()) { }
		325
		326	constexpr flat_multiset(const flat_multiset&);
		327	constexpr flat_multiset(flat_multiset&&);
		328	constexpr flat_multiset& operator=(const flat_multiset&);
		329	constexpr flat_multiset& operator=(flat_multiset&&);
		330
		331	constexpr explicit flat_multiset(const key_compare& comp)
		332	: c(), compare(comp) { }
		333
		334	constexpr explicit flat_multiset(container_type cont,
		335	const key_compare& comp = key_compare());
		336
		337	constexpr flat_multiset(sorted_equivalent_t, container_type cont,
		338	const key_compare& comp = key_compare())
		339	: c(std::move(cont)), compare(comp) { }
		340
		341	template<class InputIterator>
		342	constexpr flat_multiset(InputIterator first, InputIterator last,
		343	const key_compare& comp = key_compare())
		344	: c(), compare(comp)
		345	{ insert(first, last); }
		346
		347	template<class InputIterator>
		348	constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
		349	const key_compare& comp = key_compare())
		350	: c(first, last), compare(comp) { }
		351
		352	template<container-compatible-range<value_type> R>
		353	constexpr flat_multiset(from_range_t, R&& rg)
		354	: flat_multiset(from_range, std::forward<R>(rg), key_compare()) { }
		355	template<container-compatible-range<value_type> R>
		356	constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp)
		357	: flat_multiset(comp)
		358	{ insert_range(std::forward<R>(rg)); }
		359
		360	constexpr flat_multiset(initializer_list<value_type> il,
		361	const key_compare& comp = key_compare())
		362	: flat_multiset(il.begin(), il.end(), comp) { }
		363
		364	constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
		365	const key_compare& comp = key_compare())
		366	: flat_multiset(sorted_equivalent, il.begin(), il.end(), comp) { }
		367
		368	// [flat.multiset.cons.alloc], constructors with allocators
		369
		370	template<class Alloc>
		371	constexpr explicit flat_multiset(const Alloc& a);
		372	template<class Alloc>
		373	constexpr flat_multiset(const key_compare& comp, const Alloc& a);
		374	template<class Alloc>
		375	constexpr flat_multiset(const container_type& cont, const Alloc& a);
		376	template<class Alloc>
		377	constexpr flat_multiset(const container_type& cont, const key_compare& comp,
		378	const Alloc& a);
		379	template<class Alloc>
		380	constexpr flat_multiset(sorted_equivalent_t, const container_type& cont, const Alloc& a);
		381	template<class Alloc>
		382	constexpr flat_multiset(sorted_equivalent_t, const container_type& cont,
		383	const key_compare& comp, const Alloc& a);
		384	template<class Alloc>
		385	constexpr flat_multiset(const flat_multiset&, const Alloc& a);
		386	template<class Alloc>
		387	constexpr flat_multiset(flat_multiset&&, const Alloc& a);
		388	template<class InputIterator, class Alloc>
		389	constexpr flat_multiset(InputIterator first, InputIterator last, const Alloc& a);
		390	template<class InputIterator, class Alloc>
		391	constexpr flat_multiset(InputIterator first, InputIterator last,
		392	const key_compare& comp, const Alloc& a);
		393	template<class InputIterator, class Alloc>
		394	constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
		395	const Alloc& a);
		396	template<class InputIterator, class Alloc>
		397	constexpr flat_multiset(sorted_equivalent_t, InputIterator first, InputIterator last,
		398	const key_compare& comp, const Alloc& a);
		399	template<container-compatible-range<value_type> R, class Alloc>
		400	constexpr flat_multiset(from_range_t, R&& rg, const Alloc& a);
		401	template<container-compatible-range<value_type> R, class Alloc>
		402	constexpr flat_multiset(from_range_t, R&& rg, const key_compare& comp, const Alloc& a);
		403	template<class Alloc>
		404	constexpr flat_multiset(initializer_list<value_type> il, const Alloc& a);
		405	template<class Alloc>
		406	constexpr flat_multiset(initializer_list<value_type> il, const key_compare& comp,
		407	const Alloc& a);
		408	template<class Alloc>
		409	constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
		410	const Alloc& a);
		411	template<class Alloc>
		412	constexpr flat_multiset(sorted_equivalent_t, initializer_list<value_type> il,
		413	const key_compare& comp, const Alloc& a);
		414
		415	constexpr flat_multiset& operator=(initializer_list<value_type>);
		416
		417	// iterators
		418	constexpr iterator begin() noexcept;
		419	constexpr const_iterator begin() const noexcept;
		420	constexpr iterator end() noexcept;
		421	constexpr const_iterator end() const noexcept;
		422
		423	constexpr reverse_iterator rbegin() noexcept;
		424	constexpr const_reverse_iterator rbegin() const noexcept;
		425	constexpr reverse_iterator rend() noexcept;
		426	constexpr const_reverse_iterator rend() const noexcept;
		427
		428	constexpr const_iterator cbegin() const noexcept;
		429	constexpr const_iterator cend() const noexcept;
		430	constexpr const_reverse_iterator crbegin() const noexcept;
		431	constexpr const_reverse_iterator crend() const noexcept;
		432
		433	// capacity
		434	constexpr bool empty() const noexcept;
		435	constexpr size_type size() const noexcept;
		436	constexpr size_type max_size() const noexcept;
		437
		438	// [flat.multiset.modifiers], modifiers
		439	template<class... Args> constexpr iterator emplace(Args&&... args);
		440	template<class... Args>
		441	constexpr iterator emplace_hint(const_iterator position, Args&&... args);
		442
		443	constexpr iterator insert(const value_type& x)
		444	{ return emplace(x); }
		445	constexpr iterator insert(value_type&& x)
		446	{ return emplace(std::move(x)); }
		447	constexpr iterator insert(const_iterator position, const value_type& x)
		448	{ return emplace_hint(position, x); }
		449	constexpr iterator insert(const_iterator position, value_type&& x)
		450	{ return emplace_hint(position, std::move(x)); }
		451
		452	template<class InputIterator>
		453	constexpr void insert(InputIterator first, InputIterator last);
		454	template<class InputIterator>
		455	constexpr void insert(sorted_equivalent_t, InputIterator first, InputIterator last);
		456	template<container-compatible-range<value_type> R>
		457	constexpr void insert_range(R&& rg);
		458	template<container-compatible-range<value_type> R>
		459	constexpr void insert_range(sorted_equivalent_t, R&& rg);
		460
		461	constexpr void insert(initializer_list<value_type> il)
		462	{ insert(il.begin(), il.end()); }
		463	constexpr void insert(sorted_equivalent_t, initializer_list<value_type> il)
		464	{ insert(sorted_equivalent, il.begin(), il.end()); }
		465
		466	constexpr container_type extract() &&;
		467	constexpr void replace(container_type&&);
		468
		469	constexpr iterator erase(iterator position) requires (!same_as<iterator, const_iterator>);
		470	constexpr iterator erase(const_iterator position);
		471	constexpr size_type erase(const key_type& x);
		472	template<class K> constexpr size_type erase(K&& x);
		473	constexpr iterator erase(const_iterator first, const_iterator last);
		474
		475	constexpr void swap(flat_multiset& y) noexcept(see below);
		476	constexpr void clear() noexcept;
		477
		478	// observers
		479	constexpr key_compare key_comp() const;
		480	constexpr value_compare value_comp() const;
		481
		482	// set operations
		483	constexpr iterator find(const key_type& x);
		484	constexpr const_iterator find(const key_type& x) const;
		485	template<class K> constexpr iterator find(const K& x);
		486	template<class K> constexpr const_iterator find(const K& x) const;
		487
		488	constexpr size_type count(const key_type& x) const;
		489	template<class K> constexpr size_type count(const K& x) const;
		490
		491	constexpr bool contains(const key_type& x) const;
		492	template<class K> constexpr bool contains(const K& x) const;
		493
		494	constexpr iterator lower_bound(const key_type& x);
		495	constexpr const_iterator lower_bound(const key_type& x) const;
		496	template<class K> constexpr iterator lower_bound(const K& x);
		497	template<class K> constexpr const_iterator lower_bound(const K& x) const;
		498
		499	constexpr iterator upper_bound(const key_type& x);
		500	constexpr const_iterator upper_bound(const key_type& x) const;
		501	template<class K> constexpr iterator upper_bound(const K& x);
		502	template<class K> constexpr const_iterator upper_bound(const K& x) const;
		503
		504	constexpr pair<iterator, iterator> equal_range(const key_type& x);
		505	constexpr pair<const_iterator, const_iterator> equal_range(const key_type& x) const;
		506	template<class K>
		507	constexpr pair<iterator, iterator> equal_range(const K& x);
		508	template<class K>
		509	constexpr pair<const_iterator, const_iterator> equal_range(const K& x) const;
		510
		511	friend constexpr bool operator==(const flat_multiset& x, const flat_multiset& y);
		512
		513	friend constexpr synth-three-way-result<value_type>
		514	operator<=>(const flat_multiset& x, const flat_multiset& y);
		515
		516	friend constexpr void swap(flat_multiset& x, flat_multiset& y)
		517	noexcept(noexcept(x.swap(y)))
		518	{ x.swap(y); }
		519
		520	private:
		521	container_type c; // exposition only
		522	key_compare compare; // exposition only
		523	};
		524
		525	template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
		526	flat_multiset(KeyContainer, Compare = Compare())
		527	-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
		528	template<class KeyContainer, class Allocator>
		529	flat_multiset(KeyContainer, Allocator)
		530	-> flat_multiset<typename KeyContainer::value_type,
		531	less<typename KeyContainer::value_type>, KeyContainer>;
		532	template<class KeyContainer, class Compare, class Allocator>
		533	flat_multiset(KeyContainer, Compare, Allocator)
		534	-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
		535
		536	template<class KeyContainer, class Compare = less<typename KeyContainer::value_type>>
		537	flat_multiset(sorted_equivalent_t, KeyContainer, Compare = Compare())
		538	-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
		539	template<class KeyContainer, class Allocator>
		540	flat_multiset(sorted_equivalent_t, KeyContainer, Allocator)
		541	-> flat_multiset<typename KeyContainer::value_type,
		542	less<typename KeyContainer::value_type>, KeyContainer>;
		543	template<class KeyContainer, class Compare, class Allocator>
		544	flat_multiset(sorted_equivalent_t, KeyContainer, Compare, Allocator)
		545	-> flat_multiset<typename KeyContainer::value_type, Compare, KeyContainer>;
		546
		547	template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
		548	flat_multiset(InputIterator, InputIterator, Compare = Compare())
		549	-> flat_multiset<iter-value-type<InputIterator>, Compare>;
		550
		551	template<class InputIterator, class Compare = less<iter-value-type<InputIterator>>>
		552	flat_multiset(sorted_equivalent_t, InputIterator, InputIterator, Compare = Compare())
		553	-> flat_multiset<iter-value-type<InputIterator>, Compare>;
		554
		555	template<ranges::input_range R, class Compare = less<ranges::range_value_t<R>>,
		556	class Allocator = allocator<ranges::range_value_t<R>>>
		557	flat_multiset(from_range_t, R&&, Compare = Compare(), Allocator = Allocator())
		558	-> flat_multiset<ranges::range_value_t<R>, Compare,
		559	vector<ranges::range_value_t<R>,
		560	alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
		561
		562	template<ranges::input_range R, class Allocator>
		563	flat_multiset(from_range_t, R&&, Allocator)
		564	-> flat_multiset<ranges::range_value_t<R>, less<ranges::range_value_t<R>>,
		565	vector<ranges::range_value_t<R>,
		566	alloc-rebind<Allocator, ranges::range_value_t<R>>>>;
		567
		568	template<class Key, class Compare = less<Key>>
		569	flat_multiset(initializer_list<Key>, Compare = Compare())
		570	-> flat_multiset<Key, Compare>;
		571
		572	template<class Key, class Compare = less<Key>>
		573	flat_multiset(sorted_equivalent_t, initializer_list<Key>, Compare = Compare())
		574	-> flat_multiset<Key, Compare>;
41		575
42	template<class Key, class Compare, class KeyContainer, class Allocator>	576	template<class Key, class Compare, class KeyContainer, class Allocator>
43	struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>;	577	struct uses_allocator<flat_multiset<Key, Compare, KeyContainer>, Allocator>
		578	: bool_constant<uses_allocator_v<KeyContainer, Allocator>> { };
44		579
45	// [flat.multiset.erasure], erasure for flat_multiset	580	// [flat.multiset.erasure], erasure for flat_multiset
46	template<class Key, class Compare, class KeyContainer, class Predicate>	581	template<class Key, class Compare, class KeyContainer, class Predicate>

lib/libcxx/include/float.h+16-16

...	@@ -71,29 +71,29 @@ Macros:	...	@@ -71,29 +71,29 @@ Macros:
71	*/	71	*/
72		72
73	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	73	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
74	# include <__cxx03/float.h>	74	# include <__cxx03/__config>
75	#else	75	#else
76	# include <__config>	76	# include <__config>
		77	#endif
77		78
78	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	79	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
79	# pragma GCC system_header	80	# pragma GCC system_header
80	# endif	81	#endif
81		82
82	# if __has_include_next(<float.h>)	83	#if __has_include_next(<float.h>)
83	# include_next <float.h>	84	# include_next <float.h>
84	# endif	85	#endif
85		86
86	# ifdef __cplusplus	87	#ifdef __cplusplus
87		88
88	# ifndef FLT_EVAL_METHOD	89	# ifndef FLT_EVAL_METHOD
89	# define FLT_EVAL_METHOD __FLT_EVAL_METHOD__	90	# define FLT_EVAL_METHOD __FLT_EVAL_METHOD__
90	# endif	91	# endif
91		92
92	# ifndef DECIMAL_DIG	93	# ifndef DECIMAL_DIG
93	# define DECIMAL_DIG __DECIMAL_DIG__	94	# define DECIMAL_DIG __DECIMAL_DIG__
94	# endif	95	# endif
95		96
96	# endif // __cplusplus	97	#endif // __cplusplus
97	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
98		98
99	#endif // _LIBCPP_FLOAT_H	99	#endif // _LIBCPP_FLOAT_H

lib/libcxx/include/forward_list+33-53

 @@ -223,18 +223,17 @@ template <class T, class Allocator, class Predicate>
 #  include <__ranges/concepts.h>
 #  include <__ranges/container_compatible_range.h>
 #  include <__ranges/from_range.h>
-#  include <__type_traits/conditional.h>
 #  include <__type_traits/container_traits.h>
 #  include <__type_traits/enable_if.h>
 #  include <__type_traits/is_allocator.h>
 #  include <__type_traits/is_const.h>
 #  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
-#  include <__type_traits/is_pointer.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_swappable.h>
 #  include <__type_traits/remove_cv.h>
 #  include <__type_traits/type_identity.h>
+#  include <__utility/exception_guard.h>
 #  include <__utility/forward.h>
 #  include <__utility/move.h>
 #  include <__utility/swap.h>
 @@ -283,17 +282,6 @@ struct __forward_node_traits {
   typedef _NodePtr __node_pointer;
   typedef __forward_begin_node<_NodePtr> __begin_node;
   typedef __rebind_pointer_t<_NodePtr, __begin_node> __begin_node_pointer;
-// TODO(LLVM 22): Remove this check
-#  ifndef _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB
-  static_assert(sizeof(__begin_node_pointer) == sizeof(__node_pointer) && _LIBCPP_ALIGNOF(__begin_node_pointer) ==
-                    _LIBCPP_ALIGNOF(__node_pointer),
-                "It looks like you are using std::forward_list with a fancy pointer type that thas a different "
-                "representation depending on whether it points to a forward_list base pointer or a forward_list node "
-                "pointer (both of which are implementation details of the standard library). This means that your ABI "
-                "is being broken between LLVM 19 and LLVM 20. If you don't care about your ABI being broken, define "
-                "the _LIBCPP_ABI_FORWARD_LIST_REMOVE_NODE_POINTER_UB macro to silence this diagnostic.");
-#  endif
 };
 template <class _NodePtr>
 @@ -680,7 +668,7 @@ public:
 #  endif
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI forward_list(size_type __n, const value_type& __v);
-  template <__enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+  template <__enable_if_t<__is_allocator_v<_Alloc>, int> = 0>
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
   forward_list(size_type __n, const value_type& __v, const allocator_type& __a)
       : __base(__a) {
 @@ -744,50 +732,52 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __v);
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
     return allocator_type(this->__alloc_);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
     return iterator(__base::__before_begin()->__next_);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
     return const_iterator(__base::__before_begin()->__next_);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return iterator(nullptr); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
+    return iterator(nullptr);
+  }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
     return const_iterator(nullptr);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
     return const_iterator(__base::__before_begin()->__next_);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
     return const_iterator(nullptr);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator before_begin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator before_begin() _NOEXCEPT {
     return iterator(__base::__before_begin());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator before_begin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator before_begin() const _NOEXCEPT {
     return const_iterator(__base::__before_begin());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cbefore_begin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cbefore_begin() const _NOEXCEPT {
     return const_iterator(__base::__before_begin());
   }
   [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT {
     return __base::__before_begin()->__next_ == nullptr;
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
     return std::min<size_type>(__node_traits::max_size(this->__alloc_), numeric_limits<difference_type>::max());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reference front() {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reference front() {
     _LIBCPP_ASSERT_NON_NULL(!empty(), "forward_list::front called on an empty list");
     return __base::__before_begin()->__next_->__get_value();
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference front() const {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference front() const {
     _LIBCPP_ASSERT_NON_NULL(!empty(), "forward_list::front called on an empty list");
     return __base::__before_begin()->__next_->__get_value();
   }
 @@ -918,22 +908,22 @@ private:
 #  if _LIBCPP_STD_VER >= 17
 template <class _InputIterator,
-          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+          class _Alloc = allocator<__iterator_value_type<_InputIterator>>,
           class        = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+          class        = enable_if_t<__is_allocator_v<_Alloc>>>
-forward_list(_InputIterator, _InputIterator) -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
+forward_list(_InputIterator, _InputIterator) -> forward_list<__iterator_value_type<_InputIterator>, _Alloc>;
 template <class _InputIterator,
           class _Alloc,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Alloc>::value> >
+          class = enable_if_t<__is_allocator_v<_Alloc>>>
-forward_list(_InputIterator, _InputIterator, _Alloc) -> forward_list<__iter_value_type<_InputIterator>, _Alloc>;
+forward_list(_InputIterator, _InputIterator, _Alloc) -> forward_list<__iterator_value_type<_InputIterator>, _Alloc>;
 #  endif
 #  if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Alloc = allocator<ranges::range_value_t<_Range>>,
-          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+          class        = enable_if_t<__is_allocator_v<_Alloc>>>
 forward_list(from_range_t, _Range&&, _Alloc = _Alloc()) -> forward_list<ranges::range_value_t<_Range>, _Alloc>;
 #  endif
 @@ -1180,22 +1170,17 @@ forward_list<_Tp, _Alloc>::__insert_after(const_iterator __p, size_type __n, _Ar
   if (__n > 0) {
     __node_pointer __first = this->__create_node(/* next = */ nullptr, std::forward<_Args>(__args)...);
     __node_pointer __last  = __first;
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard           = std::__make_exception_guard([&] {
-    try {
-#  endif // _LIBCPP_HAS_EXCEPTIONS
-      for (--__n; __n != 0; --__n, __last = __last->__next_) {
-        __last->__next_ = this->__create_node(/* next = */ nullptr, std::forward<_Args>(__args)...);
-      }
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
       while (__first != nullptr) {
         __node_pointer __next = __first->__next_;
         this->__delete_node(__first);
         __first = __next;
       }
-      throw;
+    });
+    for (--__n; __n != 0; --__n, __last = __last->__next_) {
+      __last->__next_ = this->__create_node(/* next = */ nullptr, std::forward<_Args>(__args)...);
     }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
     __last->__next_ = __r->__next_;
     __r->__next_    = __first;
     __r             = std::__static_fancy_pointer_cast<__begin_node_pointer>(__last);
 @@ -1220,22 +1205,17 @@ forward_list<_Tp, _Alloc>::__insert_after_with_sentinel(const_iterator __p, _Inp
     __node_pointer __first = this->__create_node(/* next = */ nullptr, *__f);
     __node_pointer __last  = __first;
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] {
-    try {
-#  endif // _LIBCPP_HAS_EXCEPTIONS
-      for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_))) {
-        __last->__next_ = this->__create_node(/* next = */ nullptr, *__f);
-      }
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
       while (__first != nullptr) {
         __node_pointer __next = __first->__next_;
         this->__delete_node(__first);
         __first = __next;
       }
-      throw;
+    });
+    for (++__f; __f != __l; ++__f, ((void)(__last = __last->__next_))) {
+      __last->__next_ = this->__create_node(/* next = */ nullptr, *__f);
     }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
     __last->__next_ = __r->__next_;
     __r->__next_    = __first;

lib/libcxx/include/fstream+57-42

 @@ -221,7 +221,7 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-#    if _LIBCPP_STD_VER >= 26 && defined(_LIBCPP_WIN32API)
+#    if _LIBCPP_STD_VER >= 23 && defined(_LIBCPP_WIN32API)
 _LIBCPP_EXPORTED_FROM_ABI void* __filebuf_windows_native_handle(FILE* __file) noexcept;
 #    endif
 @@ -254,7 +254,7 @@ public:
   void swap(basic_filebuf& __rhs);
   // 27.9.1.4 Members:
-  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool is_open() const;
   basic_filebuf* open(const char* __s, ios_base::openmode __mode);
 #    if _LIBCPP_HAS_OPEN_WITH_WCHAR
   basic_filebuf* open(const wchar_t* __s, ios_base::openmode __mode);
 @@ -262,15 +262,14 @@ public:
   _LIBCPP_HIDE_FROM_ABI basic_filebuf* open(const string& __s, ios_base::openmode __mode);
 #    if _LIBCPP_STD_VER >= 17
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI basic_filebuf*
+  _LIBCPP_HIDE_FROM_ABI basic_filebuf* open(const filesystem::path& __p, ios_base::openmode __mode) {
-  open(const filesystem::path& __p, ios_base::openmode __mode) {
     return open(__p.c_str(), __mode);
   }
 #    endif
   _LIBCPP_HIDE_FROM_ABI basic_filebuf* __open(int __fd, ios_base::openmode __mode);
   basic_filebuf* close();
 #    if _LIBCPP_STD_VER >= 26
-  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept {
     _LIBCPP_ASSERT_UNCATEGORIZED(this->is_open(), "File must be opened");
 #      if defined(_LIBCPP_WIN32API)
     return std::__filebuf_windows_native_handle(__file_);
 @@ -299,6 +298,16 @@ protected:
   int sync() override;
   void imbue(const locale& __loc) override;
+  _LIBCPP_HIDE_FROM_ABI_VIRTUAL streamsize xsputn(const char_type* __str, streamsize __len) override {
+    if (__always_noconv_ && __len >= (this->epptr() - this->pbase())) {
+      if (traits_type::eq_int_type(overflow(), traits_type::eof()))
+        return 0;
+      return std::fwrite(__str, sizeof(char_type), __len, __file_);
+    }
+    return basic_streambuf<_CharT, _Traits>::xsputn(__str, __len);
+  }
 private:
   char* __extbuf_;
   const char* __extbufnext_;
 @@ -401,6 +410,14 @@ private:
       }
     }
   }
+  _LIBCPP_HIDE_FROM_ABI typename traits_type::int_type __overflow_failed() {
+    if (this->pptr() == this->epptr() + 1) {
+      this->pbump(-1); // lose the character we overflowed above -- we don't really have a
+                       // choice since we couldn't commit the contents of the put area
+    }
+    return traits_type::eof();
+  }
 };
 template <class _CharT, class _Traits>
 @@ -742,7 +759,12 @@ basic_filebuf<_CharT, _Traits>* basic_filebuf<_CharT, _Traits>::close() {
     if (fclose(__h.release()))
       __rt = nullptr;
     __file_ = nullptr;
-    setbuf(0, 0);
+    // Reset the get and the put areas without getting rid of the underlying buffers,
+    // which might have been configured by the user. Make sure to keep the buffers
+    // since the user may re-open the stream.
+    this->setg(nullptr, nullptr, nullptr);
+    this->setp(nullptr, nullptr);
+    __cm_ = __no_io_operations;
   }
   return __rt;
 }
 @@ -821,14 +843,6 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
 template <class _CharT, class _Traits>
 typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>::overflow(int_type __c) {
-  auto __failed = [this]() {
-    if (this->pptr() == this->epptr() + 1) {
-      this->pbump(-1); // lose the character we overflowed above -- we don't really have a
-                       // choice since we couldn't commit the contents of the put area
-    }
-    return traits_type::eof();
-  };
   if (__file_ == nullptr)
     return traits_type::eof();
   __write_mode();
 @@ -850,7 +864,7 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
   if (__always_noconv_) {
     size_t __n = static_cast<size_t>(this->pptr() - this->pbase());
     if (std::fwrite(this->pbase(), sizeof(char_type), __n, __file_) != __n) {
-      return __failed();
+      return __overflow_failed();
     }
   } else {
     if (!__cv_)
 @@ -864,14 +878,14 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
     do {
       codecvt_base::result __r = __cv_->out(__st_, __b, __p, __end, __extbuf_, __extbuf_ + __ebs_, __extbuf_end);
       if (__end == __b) {
-        return __failed();
+        return __overflow_failed();
       }
       // No conversion needed: output characters directly to the file, done.
       if (__r == codecvt_base::noconv) {
         size_t __n = static_cast<size_t>(__p - __b);
         if (std::fwrite(__b, 1, __n, __file_) != __n) {
-          return __failed();
+          return __overflow_failed();
         }
         break;
 @@ -879,7 +893,7 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
       } else if (__r == codecvt_base::ok) {
         size_t __n = static_cast<size_t>(__extbuf_end - __extbuf_);
         if (std::fwrite(__extbuf_, 1, __n, __file_) != __n) {
-          return __failed();
+          return __overflow_failed();
         }
         break;
 @@ -888,13 +902,13 @@ typename basic_filebuf<_CharT, _Traits>::int_type basic_filebuf<_CharT, _Traits>
       } else if (__r == codecvt_base::partial) {
         size_t __n = static_cast<size_t>(__extbuf_end - __extbuf_);
         if (std::fwrite(__extbuf_, 1, __n, __file_) != __n) {
-          return __failed();
+          return __overflow_failed();
         }
         __b = const_cast<char_type*>(__end);
         continue;
       } else {
-        return __failed();
+        return __overflow_failed();
       }
     } while (true);
   }
 @@ -977,7 +991,7 @@ template <class _CharT, class _Traits>
 int basic_filebuf<_CharT, _Traits>::__fseek(FILE* __file, pos_type __offset, int __whence) {
 #    if defined(_LIBCPP_MSVCRT_LIKE)
   return _fseeki64(__file, __offset, __whence);
-#    elif defined(_NEWLIB_VERSION)
+#    elif _LIBCPP_LIBC_NEWLIB
   return fseek(__file, __offset, __whence);
 #    else
   return ::fseeko(__file, __offset, __whence);
 @@ -988,7 +1002,7 @@ template <class _CharT, class _Traits>
 typename basic_filebuf<_CharT, _Traits>::pos_type basic_filebuf<_CharT, _Traits>::__ftell(FILE* __file) {
 #    if defined(_LIBCPP_MSVCRT_LIKE)
   return _ftelli64(__file);
-#    elif defined(_NEWLIB_VERSION)
+#    elif _LIBCPP_LIBC_NEWLIB
   return ftell(__file);
 #    else
   return ftello(__file);
 @@ -1147,27 +1161,27 @@ public:
   _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const string& __s, ios_base::openmode __mode = ios_base::in);
 #    if _LIBCPP_STD_VER >= 17
   template <class _Tp, class = enable_if_t<is_same_v<_Tp, filesystem::path>>>
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const _Tp& __p, ios_base::openmode __mode = ios_base::in)
-      _LIBCPP_HIDE_FROM_ABI explicit basic_ifstream(const _Tp& __p, ios_base::openmode __mode = ios_base::in)
       : basic_ifstream(__p.c_str(), __mode) {}
 #    endif // _LIBCPP_STD_VER >= 17
   _LIBCPP_HIDE_FROM_ABI basic_ifstream(basic_ifstream&& __rhs);
   _LIBCPP_HIDE_FROM_ABI basic_ifstream& operator=(basic_ifstream&& __rhs);
   _LIBCPP_HIDE_FROM_ABI void swap(basic_ifstream& __rhs);
-  _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
 #    if _LIBCPP_STD_VER >= 26
-  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept { return rdbuf()->native_handle(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept {
+    return rdbuf()->native_handle();
+  }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool is_open() const;
   void open(const char* __s, ios_base::openmode __mode = ios_base::in);
 #    if _LIBCPP_HAS_OPEN_WITH_WCHAR
   void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in);
 #    endif
   void open(const string& __s, ios_base::openmode __mode = ios_base::in);
 #    if _LIBCPP_STD_VER >= 17
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI void
+  _LIBCPP_HIDE_FROM_ABI void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) {
-  open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in) {
     return open(__p.c_str(), __mode);
   }
 #    endif // _LIBCPP_STD_VER >= 17
 @@ -1304,8 +1318,7 @@ public:
 #    if _LIBCPP_STD_VER >= 17
   template <class _Tp, class = enable_if_t<is_same_v<_Tp, filesystem::path>>>
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY
+  _LIBCPP_HIDE_FROM_ABI explicit basic_ofstream(const _Tp& __p, ios_base::openmode __mode = ios_base::out)
-      _LIBCPP_HIDE_FROM_ABI explicit basic_ofstream(const _Tp& __p, ios_base::openmode __mode = ios_base::out)
       : basic_ofstream(__p.c_str(), __mode) {}
 #    endif // _LIBCPP_STD_VER >= 17
 @@ -1313,11 +1326,13 @@ public:
   _LIBCPP_HIDE_FROM_ABI basic_ofstream& operator=(basic_ofstream&& __rhs);
   _LIBCPP_HIDE_FROM_ABI void swap(basic_ofstream& __rhs);
-  _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
 #    if _LIBCPP_STD_VER >= 26
-  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept { return rdbuf()->native_handle(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept {
+    return rdbuf()->native_handle();
+  }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool is_open() const;
   void open(const char* __s, ios_base::openmode __mode = ios_base::out);
 #    if _LIBCPP_HAS_OPEN_WITH_WCHAR
   void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::out);
 @@ -1325,8 +1340,7 @@ public:
   void open(const string& __s, ios_base::openmode __mode = ios_base::out);
 #    if _LIBCPP_STD_VER >= 17
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI void
+  _LIBCPP_HIDE_FROM_ABI void open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) {
-  open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::out) {
     return open(__p.c_str(), __mode);
   }
 #    endif // _LIBCPP_STD_VER >= 17
 @@ -1466,8 +1480,7 @@ public:
 #    if _LIBCPP_STD_VER >= 17
   template <class _Tp, class = enable_if_t<is_same_v<_Tp, filesystem::path>>>
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI explicit basic_fstream(
+  _LIBCPP_HIDE_FROM_ABI explicit basic_fstream(const _Tp& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
-      const _Tp& __p, ios_base::openmode __mode = ios_base::in | ios_base::out)
       : basic_fstream(__p.c_str(), __mode) {}
 #    endif // _LIBCPP_STD_VER >= 17
 @@ -1477,11 +1490,13 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(basic_fstream& __rhs);
-  _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_filebuf<char_type, traits_type>* rdbuf() const;
 #    if _LIBCPP_STD_VER >= 26
-  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept { return rdbuf()->native_handle(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() const noexcept {
+    return rdbuf()->native_handle();
+  }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI bool is_open() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool is_open() const;
   _LIBCPP_HIDE_FROM_ABI void open(const char* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #    if _LIBCPP_HAS_OPEN_WITH_WCHAR
   void open(const wchar_t* __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 @@ -1489,7 +1504,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void open(const string& __s, ios_base::openmode __mode = ios_base::in | ios_base::out);
 #    if _LIBCPP_STD_VER >= 17
-  _LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY _LIBCPP_HIDE_FROM_ABI void
+  _LIBCPP_HIDE_FROM_ABI void
   open(const filesystem::path& __p, ios_base::openmode __mode = ios_base::in | ios_base::out) {
     return open(__p.c_str(), __mode);
   }

lib/libcxx/include/future+41-51

 @@ -397,12 +397,14 @@ template <class R, class Alloc> struct uses_allocator<packaged_task<R>, Alloc>;
 #    include <__type_traits/decay.h>
 #    include <__type_traits/enable_if.h>
 #    include <__type_traits/invoke.h>
+#    include <__type_traits/is_constructible.h>
 #    include <__type_traits/is_same.h>
 #    include <__type_traits/remove_cvref.h>
 #    include <__type_traits/remove_reference.h>
 #    include <__type_traits/strip_signature.h>
 #    include <__type_traits/underlying_type.h>
 #    include <__utility/auto_cast.h>
+#    include <__utility/exception_guard.h>
 #    include <__utility/forward.h>
 #    include <__utility/move.h>
 #    include <__utility/swap.h>
 @@ -477,13 +479,13 @@ inline _LIBCPP_HIDE_FROM_ABI launch& operator^=(launch& __x, launch __y) {
 _LIBCPP_DECLARE_STRONG_ENUM(future_status){ready, timeout, deferred};
 _LIBCPP_DECLARE_STRONG_ENUM_EPILOG(future_status)
-_LIBCPP_EXPORTED_FROM_ABI const error_category& future_category() _NOEXCEPT;
+[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI const error_category& future_category() _NOEXCEPT;
-inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(future_errc __e) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(future_errc __e) _NOEXCEPT {
   return error_code(static_cast<int>(__e), future_category());
 }
-inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(future_errc __e) _NOEXCEPT {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(future_errc __e) _NOEXCEPT {
   return error_condition(static_cast<int>(__e), future_category());
 }
 @@ -502,7 +504,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI explicit future_error(future_errc __ec) : future_error(std::make_error_code(__ec)) {}
 #    endif
-  _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const error_code& code() const _NOEXCEPT { return __ec_; }
   _LIBCPP_HIDE_FROM_ABI future_error(const future_error&) _NOEXCEPT = default;
   ~future_error() _NOEXCEPT override;
 @@ -583,12 +585,9 @@ inline future_status __assoc_sub_state::wait_for(const chrono::duration<_Rep, _P
 template <class _Rp>
 class _LIBCPP_HIDDEN __assoc_state : public __assoc_sub_state {
   typedef __assoc_sub_state base;
-  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-  typedef typename aligned_storage<sizeof(_Rp), _LIBCPP_ALIGNOF(_Rp)>::type _Up;
-  _LIBCPP_SUPPRESS_DEPRECATED_POP
 protected:
-  _Up __value_;
+  _ALIGNAS_TYPE(_Rp) char __value_[sizeof(_Rp)];
   _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
 @@ -943,15 +942,15 @@ public:
   }
   _LIBCPP_HIDE_FROM_ABI ~future();
-  _LIBCPP_HIDE_FROM_ABI shared_future<_Rp> share() _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_future<_Rp> share() _NOEXCEPT;
   // retrieving the value
-  _LIBCPP_HIDE_FROM_ABI _Rp get();
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Rp get();
   _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // functions to check state
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
   _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
   template <class _Rep, class _Period>
 @@ -1014,15 +1013,15 @@ public:
   }
   _LIBCPP_HIDE_FROM_ABI ~future();
-  _LIBCPP_HIDE_FROM_ABI shared_future<_Rp&> share() _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI shared_future<_Rp&> share() _NOEXCEPT;
   // retrieving the value
-  _LIBCPP_HIDE_FROM_ABI _Rp& get();
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Rp& get();
   _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // functions to check state
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
   _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
   template <class _Rep, class _Period>
 @@ -1089,7 +1088,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // functions to check state
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
   _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
   template <class _Rep, class _Period>
 @@ -1139,7 +1138,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // retrieving the result
-  _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future();
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future();
   // setting the result
   _LIBCPP_HIDE_FROM_ABI void set_value(const _Rp& __r);
 @@ -1256,7 +1255,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // retrieving the result
-  _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future();
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI future<_Rp&> get_future();
   // setting the result
   _LIBCPP_HIDE_FROM_ABI void set_value(_Rp& __r);
 @@ -1366,7 +1365,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(promise& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // retrieving the result
-  future<void> get_future();
+  [[__nodiscard__]] future<void> get_future();
   // setting the result
   void set_value();
 @@ -1639,10 +1638,10 @@ public:
     __p_.swap(__other.__p_);
   }
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }
   // result retrieval
-  _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future() { return __p_.get_future(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI future<_Rp> get_future() { return __p_.get_future(); }
   // execution
   _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
 @@ -1728,10 +1727,10 @@ public:
     __p_.swap(__other.__p_);
   }
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __p_.__state_ != nullptr; }
   // result retrieval
-  _LIBCPP_HIDE_FROM_ABI future<void> get_future() { return __p_.get_future(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI future<void> get_future() { return __p_.get_future(); }
   // execution
   _LIBCPP_HIDE_FROM_ABI void operator()(_ArgTypes... __args);
 @@ -1815,16 +1814,9 @@ template <class _Rp, class _Fp>
 _LIBCPP_HIDE_FROM_ABI future<_Rp> __make_async_assoc_state(_Fp&& __f) {
   unique_ptr<__async_assoc_state<_Rp, _Fp>, __release_shared_count> __h(
       new __async_assoc_state<_Rp, _Fp>(std::forward<_Fp>(__f)));
-#    if _LIBCPP_HAS_EXCEPTIONS
+  auto __guard = std::__make_exception_guard([&] { __h->__make_ready(); });
-  try {
+  std::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
-#    endif
+  __guard.__complete();
-    std::thread(&__async_assoc_state<_Rp, _Fp>::__execute, __h.get()).detach();
-#    if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    __h->__make_ready();
-    throw;
-  }
-#    endif
   return future<_Rp>(__h.get());
 }
 @@ -1837,20 +1829,16 @@ class _LIBCPP_HIDDEN __async_func {
 public:
   using _Rp _LIBCPP_NODEBUG = __invoke_result_t<_Fp, _Args...>;
-  _LIBCPP_HIDE_FROM_ABI explicit __async_func(_Fp&& __f, _Args&&... __args)
+  template <class _Gp, class... _BArgs>
-      : __f_(std::move(__f), std::move(__args)...) {}
+  _LIBCPP_HIDE_FROM_ABI explicit __async_func(_Gp&& __g, _BArgs&&... __bargs)
+      : __f_(std::forward<_Gp>(__g), std::forward<_BArgs>(__bargs)...) {}
   _LIBCPP_HIDE_FROM_ABI __async_func(__async_func&& __f) : __f_(std::move(__f.__f_)) {}
   _LIBCPP_HIDE_FROM_ABI _Rp operator()() {
-    typedef typename __make_tuple_indices<1 + sizeof...(_Args), 1>::type _Index;
+    return [&]<size_t... _Indices>(__index_sequence<_Indices...>) -> _Rp {
-    return __execute(_Index());
+      return std::__invoke(std::move(std::get<_Indices>(__f_))...);
-  }
+    }(__index_sequence_for<_Fp, _Args...>{});
-private:
-  template <size_t... _Indices>
-  _LIBCPP_HIDE_FROM_ABI _Rp __execute(__tuple_indices<_Indices...>) {
-    return std::__invoke(std::move(std::get<0>(__f_)), std::move(std::get<_Indices>(__f_))...);
   }
 };
 @@ -1861,6 +1849,10 @@ inline _LIBCPP_HIDE_FROM_ABI bool __does_policy_contain(launch __policy, launch
 template <class _Fp, class... _Args>
 [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI future<__invoke_result_t<__decay_t<_Fp>, __decay_t<_Args>...> >
 async(launch __policy, _Fp&& __f, _Args&&... __args) {
+  static_assert(is_constructible<__decay_t<_Fp>, _Fp>::value, "");
+  static_assert(_And<is_constructible<__decay_t<_Args>, _Args>...>::value, "");
+  static_assert(__is_invocable_v<__decay_t<_Fp>, __decay_t<_Args>...>, "");
   typedef __async_func<__decay_t<_Fp>, __decay_t<_Args>...> _BF;
   typedef typename _BF::_Rp _Rp;
 @@ -1868,8 +1860,7 @@ async(launch __policy, _Fp&& __f, _Args&&... __args) {
   try {
 #      endif
     if (__does_policy_contain(__policy, launch::async))
-      return std::__make_async_assoc_state<_Rp>(
+      return std::__make_async_assoc_state<_Rp>(_BF(std::forward<_Fp>(__f), std::forward<_Args>(__args)...));
-          _BF(_LIBCPP_AUTO_CAST(std::forward<_Fp>(__f)), _LIBCPP_AUTO_CAST(std::forward<_Args>(__args))...));
 #      if _LIBCPP_HAS_EXCEPTIONS
   } catch (...) {
     if (__policy == launch::async)
 @@ -1878,8 +1869,7 @@ async(launch __policy, _Fp&& __f, _Args&&... __args) {
 #      endif
   if (__does_policy_contain(__policy, launch::deferred))
-    return std::__make_deferred_assoc_state<_Rp>(
+    return std::__make_deferred_assoc_state<_Rp>(_BF(std::forward<_Fp>(__f), std::forward<_Args>(__args)...));
-        _BF(_LIBCPP_AUTO_CAST(std::forward<_Fp>(__f)), _LIBCPP_AUTO_CAST(std::forward<_Args>(__args))...));
   return future<_Rp>{};
 }
 @@ -1915,12 +1905,12 @@ public:
   }
   // retrieving the value
-  _LIBCPP_HIDE_FROM_ABI const _Rp& get() const { return __state_->copy(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const _Rp& get() const { return __state_->copy(); }
   _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // functions to check state
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
   _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
   template <class _Rep, class _Period>
 @@ -1971,12 +1961,12 @@ public:
   }
   // retrieving the value
-  _LIBCPP_HIDE_FROM_ABI _Rp& get() const { return __state_->copy(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _Rp& get() const { return __state_->copy(); }
   _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // functions to check state
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
   _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
   template <class _Rep, class _Period>
 @@ -2032,7 +2022,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(shared_future& __rhs) _NOEXCEPT { std::swap(__state_, __rhs.__state_); }
   // functions to check state
-  _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool valid() const _NOEXCEPT { return __state_ != nullptr; }
   _LIBCPP_HIDE_FROM_ABI void wait() const { __state_->wait(); }
   template <class _Rep, class _Period>

lib/libcxx/include/initializer_list+9-3

 @@ -78,11 +78,17 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 size_t size() const _NOEXCEPT { return __size_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 size_t size() const _NOEXCEPT {
+    return __size_;
+  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* begin() const _NOEXCEPT { return __begin_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* begin() const _NOEXCEPT {
+    return __begin_;
+  }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* end() const _NOEXCEPT { return __begin_ + __size_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const _Ep* end() const _NOEXCEPT {
+    return __begin_ + __size_;
+  }
 };
 template <class _Ep>

lib/libcxx/include/inttypes.h+16-16

...	@@ -236,33 +236,33 @@ uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int	...	@@ -236,33 +236,33 @@ uintmax_t wcstoumax(const wchar_t* restrict nptr, wchar_t** restrict endptr, int
236	*/	236	*/
237		237
238	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	238	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
239	# include <__cxx03/inttypes.h>	239	# include <__cxx03/__config>
240	#else	240	#else
241	# include <__config>	241	# include <__config>
		242	#endif
242		243
243	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	244	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
244	# pragma GCC system_header	245	# pragma GCC system_header
245	# endif	246	#endif
246		247
247	/* C99 stdlib (e.g. glibc < 2.18) does not provide format macros needed	248	/* C99 stdlib (e.g. glibc < 2.18) does not provide format macros needed
248	for C++11 unless __STDC_FORMAT_MACROS is defined	249	for C++11 unless __STDC_FORMAT_MACROS is defined
249	*/	250	*/
250	# if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS)	251	#if defined(__cplusplus) && !defined(__STDC_FORMAT_MACROS)
251	# define __STDC_FORMAT_MACROS	252	# define __STDC_FORMAT_MACROS
252	# endif	253	#endif
253		254
254	# if __has_include_next(<inttypes.h>)	255	#if __has_include_next(<inttypes.h>)
255	# include_next <inttypes.h>	256	# include_next <inttypes.h>
256	# endif	257	#endif
257		258
258	# ifdef __cplusplus	259	#ifdef __cplusplus
259		260
260	# include <stdint.h>	261	# include <stdint.h>
261		262
262	# undef imaxabs	263	# undef imaxabs
263	# undef imaxdiv	264	# undef imaxdiv
264		265
265	# endif // __cplusplus	266	#endif // __cplusplus
266	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
267		267
268	#endif // _LIBCPP_INTTYPES_H	268	#endif // _LIBCPP_INTTYPES_H

lib/libcxx/include/ios+28-28

lib/libcxx/include/istream+19-13

 @@ -70,6 +70,7 @@ public:
     basic_istream& getline(char_type* s, streamsize n, char_type delim);
     basic_istream& ignore(streamsize n = 1, int_type delim = traits_type::eof());
+    basic_istream& ignore(streamsize n, char_type delim);                         // Since C++26, implemented as a DR
     int_type peek();
     basic_istream& read (char_type* s, streamsize n);
     streamsize readsome(char_type* s, streamsize n);
 @@ -172,6 +173,7 @@ template <class Stream, class T>
 #    include <__type_traits/conjunction.h>
 #    include <__type_traits/enable_if.h>
 #    include <__type_traits/is_base_of.h>
+#    include <__type_traits/is_same.h>
 #    include <__type_traits/make_unsigned.h>
 #    include <__utility/declval.h>
 #    include <__utility/forward.h>
 @@ -207,7 +209,7 @@ public:
   typedef typename traits_type::off_type off_type;
   // 27.7.1.1.1 Constructor/destructor:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb)
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 explicit basic_istream(basic_streambuf<char_type, traits_type>* __sb)
       : __gc_(0) {
     this->init(__sb);
   }
 @@ -219,7 +221,7 @@ protected:
   // 27.7.1.1.2 Assign/swap:
   inline _LIBCPP_HIDE_FROM_ABI basic_istream& operator=(basic_istream&& __rhs);
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_istream& __rhs) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void swap(basic_istream& __rhs) {
     std::swap(__gc_, __rhs.__gc_);
     basic_ios<char_type, traits_type>::swap(__rhs);
   }
 @@ -232,17 +234,17 @@ public:
   class sentry;
   // 27.7.1.2 Formatted input:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream& operator>>(basic_istream& (*__pf)(basic_istream&)) {
     return __pf(*this);
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream&
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream&
   operator>>(basic_ios<char_type, traits_type>& (*__pf)(basic_ios<char_type, traits_type>&)) {
     __pf(*this);
     return *this;
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream& operator>>(ios_base& (*__pf)(ios_base&)) {
     __pf(*this);
     return *this;
   }
 @@ -263,35 +265,39 @@ public:
   basic_istream& operator>>(void*& __p);
   // 27.7.1.3 Unformatted input:
-  _LIBCPP_HIDE_FROM_ABI streamsize gcount() const { return __gc_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI streamsize gcount() const { return __gc_; }
   int_type get();
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& get(char_type& __c) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream& get(char_type& __c) {
     int_type __ch = get();
     if (__ch != traits_type::eof())
       __c = traits_type::to_char_type(__ch);
     return *this;
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& get(char_type* __s, streamsize __n) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream& get(char_type* __s, streamsize __n) {
     return get(__s, __n, this->widen('\n'));
   }
   basic_istream& get(char_type* __s, streamsize __n, char_type __dlm);
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& get(basic_streambuf<char_type, traits_type>& __sb) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream& get(basic_streambuf<char_type, traits_type>& __sb) {
     return get(__sb, this->widen('\n'));
   }
   basic_istream& get(basic_streambuf<char_type, traits_type>& __sb, char_type __dlm);
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_istream& getline(char_type* __s, streamsize __n) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_istream& getline(char_type* __s, streamsize __n) {
     return getline(__s, __n, this->widen('\n'));
   }
   basic_istream& getline(char_type* __s, streamsize __n, char_type __dlm);
   basic_istream& ignore(streamsize __n = 1, int_type __dlm = traits_type::eof());
+  template <class _Tp = char_type, __enable_if_t<is_same<_Tp, char>::value, int> = 0>
+  _LIBCPP_HIDE_FROM_ABI basic_istream& ignore(streamsize __n, char_type __delim) {
+    return ignore(__n, traits_type::to_int_type(__delim));
+  }
   int_type peek();
   basic_istream& read(char_type* __s, streamsize __n);
   streamsize readsome(char_type* __s, streamsize __n);
 @@ -300,7 +306,7 @@ public:
   basic_istream& unget();
   int sync();
-  pos_type tellg();
+  [[__nodiscard__]] pos_type tellg();
   basic_istream& seekg(pos_type __pos);
   basic_istream& seekg(off_type __off, ios_base::seekdir __dir);
 };
 @@ -1178,7 +1184,7 @@ public:
   typedef typename traits_type::off_type off_type;
   // constructor/destructor
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 explicit basic_iostream(basic_streambuf<char_type, traits_type>* __sb)
       : basic_istream<_CharT, _Traits>(__sb) {}
   ~basic_iostream() override;
 @@ -1189,7 +1195,7 @@ protected:
   // assign/swap
   inline _LIBCPP_HIDE_FROM_ABI basic_iostream& operator=(basic_iostream&& __rhs);
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void swap(basic_iostream& __rhs) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void swap(basic_iostream& __rhs) {
     basic_istream<char_type, traits_type>::swap(__rhs);
   }
 };

lib/libcxx/include/iterator+10

...	@@ -737,6 +737,16 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;	...	@@ -737,6 +737,16 @@ template <class E> constexpr const E* data(initializer_list<E> il) noexcept;
737	# include <compare>	737	# include <compare>
738	# include <concepts>	738	# include <concepts>
739		739
		740	// [range.access.general]
		741	# if _LIBCPP_STD_VER >= 20
		742	# include <__ranges/access.h>
		743	# include <__ranges/data.h>
		744	# include <__ranges/empty.h>
		745	# include <__ranges/rbegin.h>
		746	# include <__ranges/rend.h>
		747	# include <__ranges/size.h>
		748	# endif
		749
740	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	750	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
741	# pragma GCC system_header	751	# pragma GCC system_header
742	# endif	752	# endif

lib/libcxx/include/latch+7-5

 @@ -70,7 +70,9 @@ class latch {
   atomic<ptrdiff_t> __a_;
 public:
-  static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept { return numeric_limits<ptrdiff_t>::max(); }
+  [[nodiscard]] static _LIBCPP_HIDE_FROM_ABI constexpr ptrdiff_t max() noexcept {
+    return numeric_limits<ptrdiff_t>::max();
+  }
   inline _LIBCPP_HIDE_FROM_ABI constexpr explicit latch(ptrdiff_t __expected) : __a_(__expected) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
 @@ -87,7 +89,7 @@ public:
   latch(const latch&)            = delete;
   latch& operator=(const latch&) = delete;
-  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void count_down(ptrdiff_t __update = 1) {
+  inline _LIBCPP_HIDE_FROM_ABI void count_down(ptrdiff_t __update = 1) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "latch::count_down called with a negative value");
     auto const __old = __a_.fetch_sub(__update, memory_order_release);
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
 @@ -97,16 +99,16 @@ public:
     if (__old == __update)
       __a_.notify_all();
   }
-  inline _LIBCPP_HIDE_FROM_ABI bool try_wait() const noexcept {
+  [[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI bool try_wait() const noexcept {
     auto __value = __a_.load(memory_order_acquire);
     return try_wait_impl(__value);
   }
-  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void wait() const {
+  inline _LIBCPP_HIDE_FROM_ABI void wait() const {
     std::__atomic_wait_unless(__a_, memory_order_acquire, [this](ptrdiff_t& __value) -> bool {
       return try_wait_impl(__value);
     });
   }
-  inline _LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void arrive_and_wait(ptrdiff_t __update = 1) {
+  inline _LIBCPP_HIDE_FROM_ABI void arrive_and_wait(ptrdiff_t __update = 1) {
     _LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "latch::arrive_and_wait called with a negative value");
     // other preconditions on __update are checked in count_down()

lib/libcxx/include/limits+4-4

lib/libcxx/include/list+61-79

 @@ -228,15 +228,14 @@ template <class T, class Allocator, class Predicate>
 #  include <__ranges/concepts.h>
 #  include <__ranges/container_compatible_range.h>
 #  include <__ranges/from_range.h>
-#  include <__type_traits/conditional.h>
 #  include <__type_traits/container_traits.h>
 #  include <__type_traits/enable_if.h>
 #  include <__type_traits/is_allocator.h>
 #  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
-#  include <__type_traits/is_pointer.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/type_identity.h>
+#  include <__utility/exception_guard.h>
 #  include <__utility/forward.h>
 #  include <__utility/move.h>
 #  include <__utility/swap.h>
 @@ -275,17 +274,6 @@ template <class _Tp, class _VoidPtr>
 struct __list_node_pointer_traits {
   typedef __rebind_pointer_t<_VoidPtr, __list_node<_Tp, _VoidPtr> > __node_pointer;
   typedef __rebind_pointer_t<_VoidPtr, __list_node_base<_Tp, _VoidPtr> > __base_pointer;
-// TODO(LLVM 22): Remove this check
-#  ifndef _LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB
-  static_assert(sizeof(__node_pointer) == sizeof(__node_pointer) && _LIBCPP_ALIGNOF(__base_pointer) ==
-                    _LIBCPP_ALIGNOF(__node_pointer),
-                "It looks like you are using std::list with a fancy pointer type that thas a different representation "
-                "depending on whether it points to a list base pointer or a list node pointer (both of which are "
-                "implementation details of the standard library). This means that your ABI is being broken between "
-                "LLVM 19 and LLVM 20. If you don't care about your ABI being broken, define the "
-                "_LIBCPP_ABI_LIST_REMOVE_NODE_POINTER_UB macro to silence this diagnostic.");
-#  endif
 };
 template <class _Tp, class _VoidPtr>
 @@ -724,7 +712,7 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI explicit list(size_type __n, const allocator_type& __a);
 #  endif
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI list(size_type __n, const value_type& __x);
-  template <__enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+  template <__enable_if_t<__is_allocator_v<_Alloc>, int> = 0>
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI
   list(size_type __n, const value_type& __x, const allocator_type& __a)
       : __base(__a) {
 @@ -786,57 +774,71 @@ public:
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void assign(size_type __n, const value_type& __x);
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT;
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT;
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return this->__size_; }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT {
+    return this->__size_;
+  }
   [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT {
     return __base::empty();
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
     return std::min<size_type>(this->__node_alloc_max_size(), numeric_limits<difference_type >::max());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __base::begin(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT {
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __base::begin(); }
+    return __base::begin();
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __base::end(); }
+  }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __base::end(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT {
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
+    return __base::begin();
+  }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT {
+    return __base::end();
+  }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT {
+    return __base::end();
+  }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
     return __base::begin();
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __base::end(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
+    return __base::end();
+  }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT {
     return reverse_iterator(end());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator
+  rbegin() const _NOEXCEPT {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT {
     return reverse_iterator(begin());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
     return const_reverse_iterator(begin());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator
+  crbegin() const _NOEXCEPT {
     return const_reverse_iterator(end());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
     return const_reverse_iterator(begin());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reference front() {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reference front() {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::front called on empty list");
     return __base::__end_.__next_->__as_node()->__get_value();
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference front() const {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference front() const {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::front called on empty list");
     return __base::__end_.__next_->__as_node()->__get_value();
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reference back() {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI reference back() {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::back called on empty list");
     return __base::__end_.__prev_->__as_node()->__get_value();
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference back() const {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference back() const {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "list::back called on empty list");
     return __base::__end_.__prev_->__as_node()->__get_value();
   }
 @@ -1000,22 +1002,22 @@ private:
 #  if _LIBCPP_STD_VER >= 17
 template <class _InputIterator,
-          class _Alloc = allocator<__iter_value_type<_InputIterator>>,
+          class _Alloc = allocator<__iterator_value_type<_InputIterator>>,
           class        = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+          class        = enable_if_t<__is_allocator_v<_Alloc>>>
-list(_InputIterator, _InputIterator) -> list<__iter_value_type<_InputIterator>, _Alloc>;
+list(_InputIterator, _InputIterator) -> list<__iterator_value_type<_InputIterator>, _Alloc>;
 template <class _InputIterator,
           class _Alloc,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Alloc>::value> >
+          class = enable_if_t<__is_allocator_v<_Alloc>>>
-list(_InputIterator, _InputIterator, _Alloc) -> list<__iter_value_type<_InputIterator>, _Alloc>;
+list(_InputIterator, _InputIterator, _Alloc) -> list<__iterator_value_type<_InputIterator>, _Alloc>;
 #  endif
 #  if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Alloc = allocator<ranges::range_value_t<_Range>>,
-          class        = enable_if_t<__is_allocator<_Alloc>::value> >
+          class        = enable_if_t<__is_allocator_v<_Alloc>>>
 list(from_range_t, _Range&&, _Alloc = _Alloc()) -> list<ranges::range_value_t<_Range>, _Alloc>;
 #  endif
 @@ -1233,14 +1235,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
     ++__ds;
     __r          = iterator(__node->__as_link());
     iterator __e = __r;
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] {
-    try {
-#  endif // _LIBCPP_HAS_EXCEPTIONS
-      for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
-        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, __x)->__as_link();
-      }
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
       while (true) {
         __base_pointer __prev    = __e.__ptr_->__prev_;
         __node_pointer __current = __e.__ptr_->__as_node();
 @@ -1249,9 +1244,11 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
           break;
         __e = iterator(__prev);
       }
-      throw;
+    });
+    for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
+      __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, __x)->__as_link();
     }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
     __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
     this->__size_ += __ds;
   }
 @@ -1276,14 +1273,7 @@ list<_Tp, _Alloc>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Se
     ++__ds;
     __r          = iterator(__node->__as_link());
     iterator __e = __r;
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] {
-    try {
-#  endif // _LIBCPP_HAS_EXCEPTIONS
-      for (++__f; __f != __l; ++__f, (void)++__e, ++__ds) {
-        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, *__f)->__as_link();
-      }
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
       while (true) {
         __base_pointer __prev    = __e.__ptr_->__prev_;
         __node_pointer __current = __e.__ptr_->__as_node();
 @@ -1292,9 +1282,11 @@ list<_Tp, _Alloc>::__insert_with_sentinel(const_iterator __p, _Iterator __f, _Se
           break;
         __e = iterator(__prev);
       }
-      throw;
+    });
+    for (++__f; __f != __l; ++__f, (void)++__e, ++__ds) {
+      __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, *__f)->__as_link();
     }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
     __link_nodes(__p.__ptr_, __r.__ptr_, __e.__ptr_);
     this->__size_ += __ds;
   }
 @@ -1452,14 +1444,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void list<_Tp, _Alloc>::resize(size_type __n) {
     ++__ds;
     iterator __r = iterator(__node->__as_link());
     iterator __e = __r;
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard = std::__make_exception_guard([&] {
-    try {
-#  endif // _LIBCPP_HAS_EXCEPTIONS
-      for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
-        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr)->__as_link();
-      }
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
       while (true) {
         __base_pointer __prev    = __e.__ptr_->__prev_;
         __node_pointer __current = __e.__ptr_->__as_node();
 @@ -1468,9 +1453,11 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void list<_Tp, _Alloc>::resize(size_type __n) {
           break;
         __e = iterator(__prev);
       }
-      throw;
+    });
+    for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
+      __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr)->__as_link();
     }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
     __link_nodes_at_back(__r.__ptr_, __e.__ptr_);
     this->__size_ += __ds;
   }
 @@ -1488,14 +1475,7 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void list<_Tp, _Alloc>::resize(size_type __n, cons
     __base_pointer __nl = __node->__as_link();
     iterator __r        = iterator(__nl);
     iterator __e        = __r;
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard        = std::__make_exception_guard([&] {
-    try {
-#  endif // _LIBCPP_HAS_EXCEPTIONS
-      for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
-        __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, __x)->__as_link();
-      }
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
       while (true) {
         __base_pointer __prev    = __e.__ptr_->__prev_;
         __node_pointer __current = __e.__ptr_->__as_node();
 @@ -1504,9 +1484,11 @@ _LIBCPP_CONSTEXPR_SINCE_CXX26 void list<_Tp, _Alloc>::resize(size_type __n, cons
           break;
         __e = iterator(__prev);
       }
-      throw;
+    });
+    for (--__n; __n != 0; --__n, (void)++__e, ++__ds) {
+      __e.__ptr_->__next_ = this->__create_node(/* prev = */ __e.__ptr_, /* next = */ nullptr, __x)->__as_link();
     }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    __guard.__complete();
     __link_nodes(__base::__end_as_link(), __r.__ptr_, __e.__ptr_);
     this->__size_ += __ds;
   }

lib/libcxx/include/map+386-274

...	@@ -577,12 +577,12 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred); // C++20	...	@@ -577,12 +577,12 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred); // C++20
577	# include <__algorithm/equal.h>	577	# include <__algorithm/equal.h>
578	# include <__algorithm/lexicographical_compare.h>	578	# include <__algorithm/lexicographical_compare.h>
579	# include <__algorithm/lexicographical_compare_three_way.h>	579	# include <__algorithm/lexicographical_compare_three_way.h>
		580	# include <__algorithm/specialized_algorithms.h>
580	# include <__assert>	581	# include <__assert>
581	# include <__config>	582	# include <__config>
582	# include <__functional/binary_function.h>	583	# include <__functional/binary_function.h>
583	# include <__functional/is_transparent.h>	584	# include <__functional/is_transparent.h>
584	# include <__functional/operations.h>	585	# include <__functional/operations.h>
585	# include <__fwd/map.h>
586	# include <__iterator/erase_if_container.h>	586	# include <__iterator/erase_if_container.h>
587	# include <__iterator/iterator_traits.h>	587	# include <__iterator/iterator_traits.h>
588	# include <__iterator/ranges_iterator_traits.h>	588	# include <__iterator/ranges_iterator_traits.h>
...	@@ -590,19 +590,23 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred); // C++20	...	@@ -590,19 +590,23 @@ erase_if(multimap<Key, T, Compare, Allocator>& c, Predicate pred); // C++20
590	# include <__memory/addressof.h>	590	# include <__memory/addressof.h>
591	# include <__memory/allocator.h>	591	# include <__memory/allocator.h>
592	# include <__memory/allocator_traits.h>	592	# include <__memory/allocator_traits.h>
		593	# include <__memory/compressed_pair.h>
593	# include <__memory/pointer_traits.h>	594	# include <__memory/pointer_traits.h>
594	# include <__memory/unique_ptr.h>	595	# include <__memory/unique_ptr.h>
595	# include <__memory_resource/polymorphic_allocator.h>	596	# include <__memory_resource/polymorphic_allocator.h>
596	# include <__node_handle>	597	# include <__node_handle>
		598	# include <__ranges/access.h>
597	# include <__ranges/concepts.h>	599	# include <__ranges/concepts.h>
598	# include <__ranges/container_compatible_range.h>	600	# include <__ranges/container_compatible_range.h>
599	# include <__ranges/from_range.h>	601	# include <__ranges/from_range.h>
600	# include <__tree>	602	# include <__tree>
601	# include <__type_traits/container_traits.h>	603	# include <__type_traits/container_traits.h>
602	# include <__type_traits/is_allocator.h>	604	# include <__type_traits/is_allocator.h>
		605	# include <__type_traits/make_transparent.h>
603	# include <__type_traits/remove_const.h>	606	# include <__type_traits/remove_const.h>
604	# include <__type_traits/type_identity.h>	607	# include <__type_traits/type_identity.h>
605	# include <__utility/forward.h>	608	# include <__utility/forward.h>
		609	# include <__utility/lazy_synth_three_way_comparator.h>
606	# include <__utility/pair.h>	610	# include <__utility/pair.h>
607	# include <__utility/piecewise_construct.h>	611	# include <__utility/piecewise_construct.h>
608	# include <__utility/swap.h>	612	# include <__utility/swap.h>
...	@@ -632,47 +636,9 @@ _LIBCPP_PUSH_MACROS	...	@@ -632,47 +636,9 @@ _LIBCPP_PUSH_MACROS
632		636
633	_LIBCPP_BEGIN_NAMESPACE_STD	637	_LIBCPP_BEGIN_NAMESPACE_STD
634		638
635	template <class _Key,
636	class _CP,
637	class _Compare,
638	bool = is_empty<_Compare>::value && !__libcpp_is_final<_Compare>::value>
639	class __map_value_compare : private _Compare {
640	public:
641	_LIBCPP_HIDE_FROM_ABI __map_value_compare() _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
642	: _Compare() {}
643	_LIBCPP_HIDE_FROM_ABI __map_value_compare(_Compare __c) _NOEXCEPT_(is_nothrow_copy_constructible<_Compare>::value)
644	: _Compare(__c) {}
645	_LIBCPP_HIDE_FROM_ABI const _Compare& key_comp() const _NOEXCEPT { return *this; }
646	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _CP& __y) const {
647	return static_cast<const _Compare&>(*this)(__x.first, __y.first);
648	}
649	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _Key& __y) const {
650	return static_cast<const _Compare&>(*this)(__x.first, __y);
651	}
652	_LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _CP& __y) const {
653	return static_cast<const _Compare&>(*this)(__x, __y.first);
654	}
655	_LIBCPP_HIDE_FROM_ABI void swap(__map_value_compare& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Compare>) {
656	using std::swap;
657	swap(static_cast<_Compare&>(*this), static_cast<_Compare&>(__y));
658	}
659
660	# if _LIBCPP_STD_VER >= 14
661	template <typename _K2>
662	_LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _CP& __y) const {
663	return static_cast<const _Compare&>(*this)(__x, __y.first);
664	}
665
666	template <typename _K2>
667	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _K2& __y) const {
668	return static_cast<const _Compare&>(*this)(__x.first, __y);
669	}
670	# endif
671	};
672
673	template <class _Key, class _CP, class _Compare>	639	template <class _Key, class _CP, class _Compare>
674	class __map_value_compare<_Key, _CP, _Compare, false> {	640	class __map_value_compare {
675	_Compare __comp_;	641	_LIBCPP_COMPRESSED_ELEMENT(_Compare, __comp_);
676		642
677	public:	643	public:
678	_LIBCPP_HIDE_FROM_ABI __map_value_compare() _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)	644	_LIBCPP_HIDE_FROM_ABI __map_value_compare() _NOEXCEPT_(is_nothrow_default_constructible<_Compare>::value)
...	@@ -684,7 +650,7 @@ public:	...	@@ -684,7 +650,7 @@ public:
684	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _CP& __y) const { return __comp_(__x.first, __y.first); }	650	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _CP& __y) const { return __comp_(__x.first, __y.first); }
685	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _Key& __y) const { return __comp_(__x.first, __y); }	651	_LIBCPP_HIDE_FROM_ABI bool operator()(const _CP& __x, const _Key& __y) const { return __comp_(__x.first, __y); }
686	_LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _CP& __y) const { return __comp_(__x, __y.first); }	652	_LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _CP& __y) const { return __comp_(__x, __y.first); }
687	void swap(__map_value_compare& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Compare>) {	653	_LIBCPP_HIDE_FROM_ABI void swap(__map_value_compare& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Compare>) {
688	using std::swap;	654	using std::swap;
689	swap(__comp_, __y.__comp_);	655	swap(__comp_, __y.__comp_);
690	}	656	}
...	@@ -702,9 +668,58 @@ public:	...	@@ -702,9 +668,58 @@ public:
702	# endif	668	# endif
703	};	669	};
704		670
705	template <class _Key, class _CP, class _Compare, bool __b>	671	template <class _Key, class _MapValueT, class _Compare>
		672	struct __make_transparent<_Key, __map_value_compare<_Key, _MapValueT, _Compare> > {
		673	using type _LIBCPP_NODEBUG = __map_value_compare<_Key, _MapValueT, __make_transparent_t<_Key, _Compare> >;
		674	};
		675
		676	# if _LIBCPP_STD_VER >= 14
		677	template <class _MapValueT, class _Key, class _Compare>
		678	struct __lazy_synth_three_way_comparator<__map_value_compare<_Key, _MapValueT, _Compare>, _MapValueT, _MapValueT> {
		679	__lazy_synth_three_way_comparator<_Compare, _Key, _Key> __comp_;
		680
		681	__lazy_synth_three_way_comparator(
		682	_LIBCPP_CTOR_LIFETIMEBOUND const __map_value_compare<_Key, _MapValueT, _Compare>& __comp)
		683	: __comp_(__comp.key_comp()) {}
		684
		685	_LIBCPP_HIDE_FROM_ABI auto
		686	operator()(_LIBCPP_LIFETIMEBOUND const _MapValueT& __lhs, _LIBCPP_LIFETIMEBOUND const _MapValueT& __rhs) const {
		687	return __comp_(__lhs.first, __rhs.first);
		688	}
		689	};
		690
		691	template <class _MapValueT, class _Key, class _TransparentKey, class _Compare>
		692	struct __lazy_synth_three_way_comparator<__map_value_compare<_Key, _MapValueT, _Compare>, _TransparentKey, _MapValueT> {
		693	__lazy_synth_three_way_comparator<_Compare, _TransparentKey, _Key> __comp_;
		694
		695	__lazy_synth_three_way_comparator(
		696	_LIBCPP_CTOR_LIFETIMEBOUND const __map_value_compare<_Key, _MapValueT, _Compare>& __comp)
		697	: __comp_(__comp.key_comp()) {}
		698
		699	_LIBCPP_HIDE_FROM_ABI auto
		700	operator()(_LIBCPP_LIFETIMEBOUND const _TransparentKey& __lhs, _LIBCPP_LIFETIMEBOUND const _MapValueT& __rhs) const {
		701	return __comp_(__lhs, __rhs.first);
		702	}
		703	};
		704
		705	template <class _MapValueT, class _Key, class _TransparentKey, class _Compare>
		706	struct __lazy_synth_three_way_comparator<__map_value_compare<_Key, _MapValueT, _Compare>, _MapValueT, _TransparentKey> {
		707	__lazy_synth_three_way_comparator<_Compare, _Key, _TransparentKey> __comp_;
		708
		709	__lazy_synth_three_way_comparator(
		710	_LIBCPP_CTOR_LIFETIMEBOUND const __map_value_compare<_Key, _MapValueT, _Compare>& __comp)
		711	: __comp_(__comp.key_comp()) {}
		712
		713	_LIBCPP_HIDE_FROM_ABI auto
		714	operator()(_LIBCPP_LIFETIMEBOUND const _MapValueT& __lhs, _LIBCPP_LIFETIMEBOUND const _TransparentKey& __rhs) const {
		715	return __comp_(__lhs.first, __rhs);
		716	}
		717	};
		718	# endif // _LIBCPP_STD_VER >= 14
		719
		720	template <class _Key, class _CP, class _Compare>
706	inline _LIBCPP_HIDE_FROM_ABI void	721	inline _LIBCPP_HIDE_FROM_ABI void
707	swap(__map_value_compare<_Key, _CP, _Compare, __b>& __x, __map_value_compare<_Key, _CP, _Compare, __b>& __y)	722	swap(__map_value_compare<_Key, _CP, _Compare>& __x, __map_value_compare<_Key, _CP, _Compare>& __y)
708	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {	723	_NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
709	__x.swap(__y);	724	__x.swap(__y);
710	}	725	}
...	@@ -742,9 +757,9 @@ public:	...	@@ -742,9 +757,9 @@ public:
742		757
743	_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {	758	_LIBCPP_HIDE_FROM_ABI void operator()(pointer __p) _NOEXCEPT {
744	if (__second_constructed)	759	if (__second_constructed)
745	__alloc_traits::destroy(__na_, std::addressof(__p->__value_.second));	760	__alloc_traits::destroy(__na_, std::addressof(__p->__get_value().second));
746	if (__first_constructed)	761	if (__first_constructed)
747	__alloc_traits::destroy(__na_, std::addressof(__p->__value_.first));	762	__alloc_traits::destroy(__na_, std::addressof(__p->__get_value().first));
748	if (__p)	763	if (__p)
749	__alloc_traits::deallocate(__na_, __p, 1);	764	__alloc_traits::deallocate(__na_, __p, 1);
750	}	765	}
...	@@ -804,7 +819,26 @@ public:	...	@@ -804,7 +819,26 @@ public:
804	friend class multimap;	819	friend class multimap;
805	template <class>	820	template <class>
806	friend class __map_const_iterator;	821	friend class __map_const_iterator;
		822
		823	template <class, class...>
		824	friend struct __specialized_algorithm;
		825	};
		826
		827	# ifndef _LIBCPP_CXX03_LANG
		828	template <class _Alg, class _TreeIterator>
		829	struct __specialized_algorithm<_Alg, __iterator_pair<__map_iterator<_TreeIterator>, __map_iterator<_TreeIterator>>> {
		830	using __base _LIBCPP_NODEBUG = __specialized_algorithm<_Alg, __iterator_pair<_TreeIterator, _TreeIterator>>;
		831
		832	static const bool __has_algorithm = __base::__has_algorithm;
		833
		834	using __iterator _LIBCPP_NODEBUG = __map_iterator<_TreeIterator>;
		835
		836	template <class... _Args>
		837	_LIBCPP_HIDE_FROM_ABI static void operator()(__iterator __first, __iterator __last, _Args&&... __args) {
		838	__base()(__first.__i_, __last.__i_, std::forward<_Args>(__args)...);
		839	}
807	};	840	};
		841	# endif
808		842
809	template <class _TreeIterator>	843	template <class _TreeIterator>
810	class __map_const_iterator {	844	class __map_const_iterator {
...	@@ -859,9 +893,33 @@ public:	...	@@ -859,9 +893,33 @@ public:
859	friend class multimap;	893	friend class multimap;
860	template <class, class, class>	894	template <class, class, class>
861	friend class __tree_const_iterator;	895	friend class __tree_const_iterator;
		896
		897	template <class, class...>
		898	friend struct __specialized_algorithm;
862	};	899	};
863		900
864	template <class _Key, class _Tp, class _Compare, class _Allocator>	901	# ifndef _LIBCPP_CXX03_LANG
		902	template <class _Alg, class _TreeIterator>
		903	struct __specialized_algorithm<
		904	_Alg,
		905	__iterator_pair<__map_const_iterator<_TreeIterator>, __map_const_iterator<_TreeIterator>>> {
		906	using __base _LIBCPP_NODEBUG = __specialized_algorithm<_Alg, __iterator_pair<_TreeIterator, _TreeIterator>>;
		907
		908	static const bool __has_algorithm = __base::__has_algorithm;
		909
		910	using __iterator _LIBCPP_NODEBUG = __map_const_iterator<_TreeIterator>;
		911
		912	template <class... _Args>
		913	_LIBCPP_HIDE_FROM_ABI static void operator()(__iterator __first, __iterator __last, _Args&&... __args) {
		914	__base()(__first.__i_, __last.__i_, std::forward<_Args>(__args)...);
		915	}
		916	};
		917	# endif
		918
		919	template <class _Key, class _Tp, class _Compare = less<_Key>, class _Allocator = allocator<pair<const _Key, _Tp> > >
		920	class multimap;
		921
		922	template <class _Key, class _Tp, class _Compare = less<_Key>, class _Allocator = allocator<pair<const _Key, _Tp> > >
865	class map {	923	class map {
866	public:	924	public:
867	// types:	925	// types:
...	@@ -970,17 +1028,17 @@ public:	...	@@ -970,17 +1028,17 @@ public:
970	: map(from_range, std::forward<_Range>(__range), key_compare(), __a) {}	1028	: map(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
971	# endif	1029	# endif
972		1030
973	_LIBCPP_HIDE_FROM_ABI map(const map& __m) : __tree_(__m.__tree_) { insert(__m.begin(), __m.end()); }	1031	_LIBCPP_HIDE_FROM_ABI map(const map& __m) = default;
974		1032
975	_LIBCPP_HIDE_FROM_ABI map& operator=(const map& __m) = default;	1033	_LIBCPP_HIDE_FROM_ABI map& operator=(const map& __m) = default;
976		1034
977	# ifndef _LIBCPP_CXX03_LANG	1035	# ifndef _LIBCPP_CXX03_LANG
978		1036
979	_LIBCPP_HIDE_FROM_ABI map(map&& __m) noexcept(is_nothrow_move_constructible<__base>::value) = default;	1037	_LIBCPP_HIDE_FROM_ABI map(map&& __m) = default;
980		1038
981	_LIBCPP_HIDE_FROM_ABI map(map&& __m, const allocator_type& __a);	1039	_LIBCPP_HIDE_FROM_ABI map(map&& __m, const allocator_type& __a) : __tree_(std::move(__m.__tree_), __a) {}
982		1040
983	_LIBCPP_HIDE_FROM_ABI map& operator=(map&& __m) noexcept(is_nothrow_move_assignable<__base>::value) = default;	1041	_LIBCPP_HIDE_FROM_ABI map& operator=(map&& __m) = default;
984		1042
985	_LIBCPP_HIDE_FROM_ABI map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())	1043	_LIBCPP_HIDE_FROM_ABI map(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
986	: __tree_(__vc(__comp)) {	1044	: __tree_(__vc(__comp)) {
...	@@ -998,7 +1056,8 @@ public:	...	@@ -998,7 +1056,8 @@ public:
998	# endif	1056	# endif
999		1057
1000	_LIBCPP_HIDE_FROM_ABI map& operator=(initializer_list<value_type> __il) {	1058	_LIBCPP_HIDE_FROM_ABI map& operator=(initializer_list<value_type> __il) {
1001	__tree_.__assign_unique(__il.begin(), __il.end());	1059	clear();
		1060	insert(__il.begin(), __il.end());
1002	return *this;	1061	return *this;
1003	}	1062	}
1004		1063
...	@@ -1006,43 +1065,66 @@ public:	...	@@ -1006,43 +1065,66 @@ public:
1006		1065
1007	_LIBCPP_HIDE_FROM_ABI explicit map(const allocator_type& __a) : __tree_(typename __base::allocator_type(__a)) {}	1066	_LIBCPP_HIDE_FROM_ABI explicit map(const allocator_type& __a) : __tree_(typename __base::allocator_type(__a)) {}
1008		1067
1009	_LIBCPP_HIDE_FROM_ABI map(const map& __m, const allocator_type& __a)	1068	_LIBCPP_HIDE_FROM_ABI map(const map& __m, const allocator_type& __alloc) : __tree_(__m.__tree_, __alloc) {}
1010	: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a)) {
1011	insert(__m.begin(), __m.end());
1012	}
1013		1069
1014	_LIBCPP_HIDE_FROM_ABI ~map() { static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), ""); }	1070	_LIBCPP_HIDE_FROM_ABI ~map() { static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
1015		1071
1016	_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }	1072	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
1017	_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }	1073	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
1018	_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }	1074	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
1019	_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }	1075	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
1020		1076
1021	_LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }	1077	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
1022	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }	1078	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
1023	_LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }	1079	return const_reverse_iterator(end());
1024	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }	1080	}
		1081	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
		1082	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
		1083	return const_reverse_iterator(begin());
		1084	}
1025		1085
1026	_LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }	1086	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
1027	_LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }	1087	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
1028	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }	1088	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
1029	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }	1089	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
1030		1090
1031	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }	1091	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
1032	_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }	1092	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
1033	_LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }	1093	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
1034		1094
1035	_LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);	1095	_LIBCPP_HIDE_FROM_ABI mapped_type& operator[](const key_type& __k);
1036	# ifndef _LIBCPP_CXX03_LANG	1096	# ifndef _LIBCPP_CXX03_LANG
1037	_LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);	1097	_LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);
1038	# endif	1098	# endif
1039		1099
1040	_LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);	1100	template <class _Arg,
1041	_LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;	1101	__enable_if_t<__is_transparently_comparable_v<_Compare, key_type, __remove_cvref_t<_Arg> >, int> = 0>
		1102	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mapped_type& at(_Arg&& __arg) {
		1103	auto [_, __child] = __tree_.__find_equal(__arg);
		1104	if (__child == nullptr)
		1105	std::__throw_out_of_range("map::at: key not found");
		1106	return static_cast<__node_pointer>(__child)->__get_value().second;
		1107	}
		1108
		1109	template <class _Arg,
		1110	__enable_if_t<__is_transparently_comparable_v<_Compare, key_type, __remove_cvref_t<_Arg> >, int> = 0>
		1111	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const mapped_type& at(_Arg&& __arg) const {
		1112	auto [_, __child] = __tree_.__find_equal(__arg);
		1113	if (__child == nullptr)
		1114	std::__throw_out_of_range("map::at: key not found");
		1115	return static_cast<__node_pointer>(__child)->__get_value().second;
		1116	}
1042		1117
1043	_LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return allocator_type(__tree_.__alloc()); }	1118	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);
1044	_LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp().key_comp(); }	1119	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
1045	_LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__tree_.value_comp().key_comp()); }	1120
		1121	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
		1122	return allocator_type(__tree_.__alloc());
		1123	}
		1124	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp().key_comp(); }
		1125	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const {
		1126	return value_compare(__tree_.value_comp().key_comp());
		1127	}
1046		1128
1047	# ifndef _LIBCPP_CXX03_LANG	1129	# ifndef _LIBCPP_CXX03_LANG
1048	template <class... _Args>	1130	template <class... _Args>
...	@@ -1052,7 +1134,7 @@ public:	...	@@ -1052,7 +1134,7 @@ public:
1052		1134
1053	template <class... _Args>	1135	template <class... _Args>
1054	_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {	1136	_LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
1055	return __tree_.__emplace_hint_unique(__p.__i_, std::forward<_Args>(__args)...);	1137	return __tree_.__emplace_hint_unique(__p.__i_, std::forward<_Args>(__args)...).first;
1056	}	1138	}
1057		1139
1058	template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>	1140	template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
...	@@ -1062,7 +1144,7 @@ public:	...	@@ -1062,7 +1144,7 @@ public:
1062		1144
1063	template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>	1145	template <class _Pp, __enable_if_t<is_constructible<value_type, _Pp>::value, int> = 0>
1064	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __pos, _Pp&& __p) {	1146	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __pos, _Pp&& __p) {
1065	return __tree_.__emplace_hint_unique(__pos.__i_, std::forward<_Pp>(__p));	1147	return __tree_.__emplace_hint_unique(__pos.__i_, std::forward<_Pp>(__p)).first;
1066	}	1148	}
1067		1149
1068	# endif // _LIBCPP_CXX03_LANG	1150	# endif // _LIBCPP_CXX03_LANG
...	@@ -1070,7 +1152,7 @@ public:	...	@@ -1070,7 +1152,7 @@ public:
1070	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __v) { return __tree_.__emplace_unique(__v); }	1152	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __v) { return __tree_.__emplace_unique(__v); }
1071		1153
1072	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {	1154	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {
1073	return __tree_.__emplace_hint_unique(__p.__i_, __v);	1155	return __tree_.__emplace_hint_unique(__p.__i_, __v).first;
1074	}	1156	}
1075		1157
1076	# ifndef _LIBCPP_CXX03_LANG	1158	# ifndef _LIBCPP_CXX03_LANG
...	@@ -1079,25 +1161,21 @@ public:	...	@@ -1079,25 +1161,21 @@ public:
1079	}	1161	}
1080		1162
1081	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {	1163	_LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {
1082	return __tree_.__emplace_hint_unique(__p.__i_, std::move(__v));	1164	return __tree_.__emplace_hint_unique(__p.__i_, std::move(__v)).first;
1083	}	1165	}
1084		1166
1085	_LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }	1167	_LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
1086	# endif	1168	# endif
1087		1169
1088	template <class _InputIterator>	1170	template <class _InputIterator>
1089	_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {	1171	_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
1090	for (const_iterator __e = cend(); __f != __l; ++__f)	1172	__tree_.__insert_range_unique(__first, __last);
1091	insert(__e.__i_, *__f);
1092	}	1173	}
1093		1174
1094	# if _LIBCPP_STD_VER >= 23	1175	# if _LIBCPP_STD_VER >= 23
1095	template <_ContainerCompatibleRange<value_type> _Range>	1176	template <_ContainerCompatibleRange<value_type> _Range>
1096	_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {	1177	_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
1097	const_iterator __end = cend();	1178	__tree_.__insert_range_unique(ranges::begin(__range), ranges::end(__range));
1098	for (auto&& __element : __range) {
1099	insert(__end.__i_, std::forward<decltype(__element)>(__element));
1100	}
1101	}	1179	}
1102	# endif	1180	# endif
1103		1181
...	@@ -1105,17 +1183,13 @@ public:	...	@@ -1105,17 +1183,13 @@ public:
1105		1183
1106	template <class... _Args>	1184	template <class... _Args>
1107	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) {	1185	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) {
1108	return __tree_.__emplace_unique_key_args(	1186	return __tree_.__emplace_unique(
1109	__k,	1187	std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple(std::forward<_Args>(__args)...));
1110	std::piecewise_construct,
1111	std::forward_as_tuple(__k),
1112	std::forward_as_tuple(std::forward<_Args>(__args)...));
1113	}	1188	}
1114		1189
1115	template <class... _Args>	1190	template <class... _Args>
1116	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) {	1191	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) {
1117	return __tree_.__emplace_unique_key_args(	1192	return __tree_.__emplace_unique(
1118	__k,
1119	std::piecewise_construct,	1193	std::piecewise_construct,
1120	std::forward_as_tuple(std::move(__k)),	1194	std::forward_as_tuple(std::move(__k)),
1121	std::forward_as_tuple(std::forward<_Args>(__args)...));	1195	std::forward_as_tuple(std::forward<_Args>(__args)...));
...	@@ -1124,9 +1198,8 @@ public:	...	@@ -1124,9 +1198,8 @@ public:
1124	template <class... _Args>	1198	template <class... _Args>
1125	_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) {	1199	_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __h, const key_type& __k, _Args&&... __args) {
1126	return __tree_	1200	return __tree_
1127	.__emplace_hint_unique_key_args(	1201	.__emplace_hint_unique(
1128	__h.__i_,	1202	__h.__i_,
1129	__k,
1130	std::piecewise_construct,	1203	std::piecewise_construct,
1131	std::forward_as_tuple(__k),	1204	std::forward_as_tuple(__k),
1132	std::forward_as_tuple(std::forward<_Args>(__args)...))	1205	std::forward_as_tuple(std::forward<_Args>(__args)...))
...	@@ -1136,9 +1209,8 @@ public:	...	@@ -1136,9 +1209,8 @@ public:
1136	template <class... _Args>	1209	template <class... _Args>
1137	_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) {	1210	_LIBCPP_HIDE_FROM_ABI iterator try_emplace(const_iterator __h, key_type&& __k, _Args&&... __args) {
1138	return __tree_	1211	return __tree_
1139	.__emplace_hint_unique_key_args(	1212	.__emplace_hint_unique(
1140	__h.__i_,	1213	__h.__i_,
1141	__k,
1142	std::piecewise_construct,	1214	std::piecewise_construct,
1143	std::forward_as_tuple(std::move(__k)),	1215	std::forward_as_tuple(std::move(__k)),
1144	std::forward_as_tuple(std::forward<_Args>(__args)...))	1216	std::forward_as_tuple(std::forward<_Args>(__args)...))
...	@@ -1147,27 +1219,25 @@ public:	...	@@ -1147,27 +1219,25 @@ public:
1147		1219
1148	template <class _Vp>	1220	template <class _Vp>
1149	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) {	1221	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) {
1150	iterator __p = lower_bound(__k);	1222	auto __result = __tree_.__emplace_unique(__k, std::forward<_Vp>(__v));
1151	if (__p != end() && !key_comp()(__k, __p->first)) {	1223	auto& [__iter, __inserted] = __result;
1152	__p->second = std::forward<_Vp>(__v);	1224	if (!__inserted)
1153	return std::make_pair(__p, false);	1225	__iter->second = std::forward<_Vp>(__v);
1154	}	1226	return __result;
1155	return std::make_pair(emplace_hint(__p, __k, std::forward<_Vp>(__v)), true);
1156	}	1227	}
1157		1228
1158	template <class _Vp>	1229	template <class _Vp>
1159	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) {	1230	_LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) {
1160	iterator __p = lower_bound(__k);	1231	auto __result = __tree_.__emplace_unique(std::move(__k), std::forward<_Vp>(__v));
1161	if (__p != end() && !key_comp()(__k, __p->first)) {	1232	auto& [__iter, __inserted] = __result;
1162	__p->second = std::forward<_Vp>(__v);	1233	if (!__inserted)
1163	return std::make_pair(__p, false);	1234	__iter->second = std::forward<_Vp>(__v);
1164	}	1235	return __result;
1165	return std::make_pair(emplace_hint(__p, std::move(__k), std::forward<_Vp>(__v)), true);
1166	}	1236	}
1167		1237
1168	template <class _Vp>	1238	template <class _Vp>
1169	_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v) {	1239	_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __h, const key_type& __k, _Vp&& __v) {
1170	auto [__r, __inserted] = __tree_.__emplace_hint_unique_key_args(__h.__i_, __k, __k, std::forward<_Vp>(__v));	1240	auto [__r, __inserted] = __tree_.__emplace_hint_unique(__h.__i_, __k, std::forward<_Vp>(__v));
1171		1241
1172	if (!__inserted)	1242	if (!__inserted)
1173	__r->second = std::forward<_Vp>(__v);	1243	__r->second = std::forward<_Vp>(__v);
...	@@ -1177,8 +1247,7 @@ public:	...	@@ -1177,8 +1247,7 @@ public:
1177		1247
1178	template <class _Vp>	1248	template <class _Vp>
1179	_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v) {	1249	_LIBCPP_HIDE_FROM_ABI iterator insert_or_assign(const_iterator __h, key_type&& __k, _Vp&& __v) {
1180	auto [__r, __inserted] =	1250	auto [__r, __inserted] = __tree_.__emplace_hint_unique(__h.__i_, std::move(__k), std::forward<_Vp>(__v));
1181	__tree_.__emplace_hint_unique_key_args(__h.__i_, __k, std::move(__k), std::forward<_Vp>(__v));
1182		1251
1183	if (!__inserted)	1252	if (!__inserted)
1184	__r->second = std::forward<_Vp>(__v);	1253	__r->second = std::forward<_Vp>(__v);
...	@@ -1207,10 +1276,10 @@ public:	...	@@ -1207,10 +1276,10 @@ public:
1207	"node_type with incompatible allocator passed to map::insert()");	1276	"node_type with incompatible allocator passed to map::insert()");
1208	return __tree_.template __node_handle_insert_unique<node_type>(__hint.__i_, std::move(__nh));	1277	return __tree_.template __node_handle_insert_unique<node_type>(__hint.__i_, std::move(__nh));
1209	}	1278	}
1210	_LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {	1279	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
1211	return __tree_.template __node_handle_extract<node_type>(__key);	1280	return __tree_.template __node_handle_extract<node_type>(__key);
1212	}	1281	}
1213	_LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {	1282	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
1214	return __tree_.template __node_handle_extract<node_type>(__it.__i_);	1283	return __tree_.template __node_handle_extract<node_type>(__it.__i_);
1215	}	1284	}
1216	template <class _Compare2>	1285	template <class _Compare2>
...	@@ -1241,75 +1310,105 @@ public:	...	@@ -1241,75 +1310,105 @@ public:
1241		1310
1242	_LIBCPP_HIDE_FROM_ABI void swap(map& __m) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) { __tree_.swap(__m.__tree_); }	1311	_LIBCPP_HIDE_FROM_ABI void swap(map& __m) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) { __tree_.swap(__m.__tree_); }
1243		1312
1244	_LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }	1313	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
1245	_LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }	1314	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
1246	# if _LIBCPP_STD_VER >= 14	1315	# if _LIBCPP_STD_VER >= 14
1247	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1316	template <typename _K2,
1248	_LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {	1317	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
		1318	int> = 0>
		1319	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
1249	return __tree_.find(__k);	1320	return __tree_.find(__k);
1250	}	1321	}
1251	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1322	template <typename _K2,
1252	_LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {	1323	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
		1324	int> = 0>
		1325	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
1253	return __tree_.find(__k);	1326	return __tree_.find(__k);
1254	}	1327	}
1255	# endif	1328	# endif
1256		1329
1257	_LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_unique(__k); }	1330	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
		1331	return __tree_.__count_unique(__k);
		1332	}
1258	# if _LIBCPP_STD_VER >= 14	1333	# if _LIBCPP_STD_VER >= 14
1259	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1334	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1260	_LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {	1335	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
1261	return __tree_.__count_multi(__k);	1336	return __tree_.__count_multi(__k);
1262	}	1337	}
1263	# endif	1338	# endif
1264		1339
1265	# if _LIBCPP_STD_VER >= 20	1340	# if _LIBCPP_STD_VER >= 20
1266	_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }	1341	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
1267	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1342	template <typename _K2,
1268	_LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {	1343	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
		1344	int> = 0>
		1345	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
1269	return find(__k) != end();	1346	return find(__k) != end();
1270	}	1347	}
1271	# endif // _LIBCPP_STD_VER >= 20	1348	# endif // _LIBCPP_STD_VER >= 20
1272		1349
1273	_LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }	1350	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) {
1274	_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }	1351	return __tree_.__lower_bound_unique(__k);
		1352	}
		1353
		1354	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const {
		1355	return __tree_.__lower_bound_unique(__k);
		1356	}
		1357
		1358	// The transparent versions of the lookup functions use the _multi version, since a non-element key is allowed to
		1359	// match multiple elements.
1275	# if _LIBCPP_STD_VER >= 14	1360	# if _LIBCPP_STD_VER >= 14
1276	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1361	template <typename _K2,
1277	_LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {	1362	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
1278	return __tree_.lower_bound(__k);	1363	int> = 0>
		1364	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
		1365	return __tree_.__lower_bound_multi(__k);
1279	}	1366	}
1280		1367
1281	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1368	template <typename _K2,
1282	_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {	1369	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
1283	return __tree_.lower_bound(__k);	1370	int> = 0>
		1371	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
		1372	return __tree_.__lower_bound_multi(__k);
1284	}	1373	}
1285	# endif	1374	# endif
1286		1375
1287	_LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }	1376	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) {
1288	_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }	1377	return __tree_.__upper_bound_unique(__k);
1289	# if _LIBCPP_STD_VER >= 14
1290	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1291	_LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
1292	return __tree_.upper_bound(__k);
1293	}	1378	}
1294	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1379
1295	_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {	1380	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const {
1296	return __tree_.upper_bound(__k);	1381	return __tree_.__upper_bound_unique(__k);
		1382	}
		1383
		1384	# if _LIBCPP_STD_VER >= 14
		1385	template <typename _K2,
		1386	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
		1387	int> = 0>
		1388	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
		1389	return __tree_.__upper_bound_multi(__k);
		1390	}
		1391	template <typename _K2,
		1392	enable_if_t<__is_transparent_v<_Compare, _K2> \|\| __is_transparently_comparable_v<_Compare, key_type, _K2>,
		1393	int> = 0>
		1394	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
		1395	return __tree_.__upper_bound_multi(__k);
1297	}	1396	}
1298	# endif	1397	# endif
1299		1398
1300	_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {	1399	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
1301	return __tree_.__equal_range_unique(__k);	1400	return __tree_.__equal_range_unique(__k);
1302	}	1401	}
1303	_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {	1402	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
1304	return __tree_.__equal_range_unique(__k);	1403	return __tree_.__equal_range_unique(__k);
1305	}	1404	}
1306	# if _LIBCPP_STD_VER >= 14	1405	# if _LIBCPP_STD_VER >= 14
1307	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1406	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1308	_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {	1407	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
1309	return __tree_.__equal_range_multi(__k);	1408	return __tree_.__equal_range_multi(__k);
1310	}	1409	}
1311	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1410	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1312	_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {	1411	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
1313	return __tree_.__equal_range_multi(__k);	1412	return __tree_.__equal_range_multi(__k);
1314	}	1413	}
1315	# endif	1414	# endif
...	@@ -1319,7 +1418,6 @@ private:	...	@@ -1319,7 +1418,6 @@ private:
1319	typedef typename __base::__node_allocator __node_allocator;	1418	typedef typename __base::__node_allocator __node_allocator;
1320	typedef typename __base::__node_pointer __node_pointer;	1419	typedef typename __base::__node_pointer __node_pointer;
1321	typedef typename __base::__node_base_pointer __node_base_pointer;	1420	typedef typename __base::__node_base_pointer __node_base_pointer;
1322	typedef typename __base::__parent_pointer __parent_pointer;
1323		1421
1324	typedef __map_node_destructor<__node_allocator> _Dp;	1422	typedef __map_node_destructor<__node_allocator> _Dp;
1325	typedef unique_ptr<__node, _Dp> __node_holder;	1423	typedef unique_ptr<__node, _Dp> __node_holder;
...	@@ -1327,6 +1425,8 @@ private:	...	@@ -1327,6 +1425,8 @@ private:
1327	# ifdef _LIBCPP_CXX03_LANG	1425	# ifdef _LIBCPP_CXX03_LANG
1328	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_with_key(const key_type& __k);	1426	_LIBCPP_HIDE_FROM_ABI __node_holder __construct_node_with_key(const key_type& __k);
1329	# endif	1427	# endif
		1428
		1429	friend struct __specialized_algorithm<_Algorithm::__for_each, __single_range<map> >;
1330	};	1430	};
1331		1431
1332	# if _LIBCPP_STD_VER >= 17	1432	# if _LIBCPP_STD_VER >= 17
...	@@ -1334,8 +1434,8 @@ template <class _InputIterator,	...	@@ -1334,8 +1434,8 @@ template <class _InputIterator,
1334	class _Compare = less<__iter_key_type<_InputIterator>>,	1434	class _Compare = less<__iter_key_type<_InputIterator>>,
1335	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,	1435	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
1336	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,	1436	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
1337	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	1437	class = enable_if_t<!__is_allocator_v<_Compare>>,
1338	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1438	class = enable_if_t<__is_allocator_v<_Allocator>>>
1339	map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())	1439	map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
1340	-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;	1440	-> map<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
1341		1441
...	@@ -1343,8 +1443,8 @@ map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocat	...	@@ -1343,8 +1443,8 @@ map(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocat
1343	template <ranges::input_range _Range,	1443	template <ranges::input_range _Range,
1344	class _Compare = less<__range_key_type<_Range>>,	1444	class _Compare = less<__range_key_type<_Range>>,
1345	class _Allocator = allocator<__range_to_alloc_type<_Range>>,	1445	class _Allocator = allocator<__range_to_alloc_type<_Range>>,
1346	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	1446	class = enable_if_t<!__is_allocator_v<_Compare>>,
1347	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1447	class = enable_if_t<__is_allocator_v<_Allocator>>>
1348	map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())	1448	map(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
1349	-> map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;	1449	-> map<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;
1350	# endif	1450	# endif
...	@@ -1353,16 +1453,15 @@ template <class _Key,	...	@@ -1353,16 +1453,15 @@ template <class _Key,
1353	class _Tp,	1453	class _Tp,
1354	class _Compare = less<remove_const_t<_Key>>,	1454	class _Compare = less<remove_const_t<_Key>>,
1355	class _Allocator = allocator<pair<const _Key, _Tp>>,	1455	class _Allocator = allocator<pair<const _Key, _Tp>>,
1356	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	1456	class = enable_if_t<!__is_allocator_v<_Compare>>,
1357	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1457	class = enable_if_t<__is_allocator_v<_Allocator>>>
1358	map(initializer_list<pair<_Key, _Tp>>,	1458	map(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
1359	_Compare = _Compare(),	1459	-> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
1360	_Allocator = _Allocator()) -> map<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
1361		1460
1362	template <class _InputIterator,	1461	template <class _InputIterator,
1363	class _Allocator,	1462	class _Allocator,
1364	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,	1463	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
1365	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1464	class = enable_if_t<__is_allocator_v<_Allocator>>>
1366	map(_InputIterator, _InputIterator, _Allocator)	1465	map(_InputIterator, _InputIterator, _Allocator)
1367	-> map<__iter_key_type<_InputIterator>,	1466	-> map<__iter_key_type<_InputIterator>,
1368	__iter_mapped_type<_InputIterator>,	1467	__iter_mapped_type<_InputIterator>,
...	@@ -1370,44 +1469,44 @@ map(_InputIterator, _InputIterator, _Allocator)	...	@@ -1370,44 +1469,44 @@ map(_InputIterator, _InputIterator, _Allocator)
1370	_Allocator>;	1469	_Allocator>;
1371		1470
1372	# if _LIBCPP_STD_VER >= 23	1471	# if _LIBCPP_STD_VER >= 23
1373	template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1472	template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
1374	map(from_range_t, _Range&&, _Allocator)	1473	map(from_range_t, _Range&&, _Allocator)
1375	-> map<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;	1474	-> map<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;
1376	# endif	1475	# endif
1377		1476
1378	template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>	1477	template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
1379	map(initializer_list<pair<_Key, _Tp>>,	1478	map(initializer_list<pair<_Key, _Tp>>, _Allocator)
1380	_Allocator) -> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;	1479	-> map<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
1381	# endif	1480	# endif
1382		1481
1383	# ifndef _LIBCPP_CXX03_LANG	1482	# if _LIBCPP_STD_VER >= 14
1384	template <class _Key, class _Tp, class _Compare, class _Allocator>	1483	template <class _Key, class _Tp, class _Compare, class _Allocator>
1385	map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)	1484	struct __specialized_algorithm<_Algorithm::__for_each, __single_range<map<_Key, _Tp, _Compare, _Allocator>>> {
1386	: __tree_(std::move(__m.__tree_), typename __base::allocator_type(__a)) {	1485	using __map _LIBCPP_NODEBUG = map<_Key, _Tp, _Compare, _Allocator>;
1387	if (__a != __m.get_allocator()) {	1486
1388	const_iterator __e = cend();	1487	static const bool __has_algorithm = true;
1389	while (!__m.empty()) {	1488
1390	__tree_.__insert_unique_from_orphaned_node(__e.__i_, std::move(__m.__tree_.remove(__m.begin().__i_)->__value_));	1489	template <class _Map, class _Func, class _Proj>
1391	}	1490	_LIBCPP_HIDE_FROM_ABI static auto operator()(_Map&& __map, _Func __func, _Proj __proj) {
		1491	auto [_, __func2] = __specialized_algorithm<_Algorithm::__for_each, __single_range<typename __map::__base>>()(
		1492	__map.__tree_, std::move(__func), std::move(__proj));
		1493	return std::make_pair(__map.end(), std::move(__func2));
1392	}	1494	}
1393	}	1495	};
		1496	# endif
1394		1497
		1498	# ifndef _LIBCPP_CXX03_LANG
1395	template <class _Key, class _Tp, class _Compare, class _Allocator>	1499	template <class _Key, class _Tp, class _Compare, class _Allocator>
1396	_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) {	1500	_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) {
1397	return __tree_	1501	return __tree_.__emplace_unique(std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple())
1398	.__emplace_unique_key_args(__k, std::piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple())
1399	.first->second;	1502	.first->second;
1400	}	1503	}
1401		1504
1402	template <class _Key, class _Tp, class _Compare, class _Allocator>	1505	template <class _Key, class _Tp, class _Compare, class _Allocator>
1403	_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k) {	1506	_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k) {
1404	// TODO investigate this clang-tidy warning.
1405	// NOLINTBEGIN(bugprone-use-after-move)
1406	return __tree_	1507	return __tree_
1407	.__emplace_unique_key_args(	1508	.__emplace_unique(std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple())
1408	__k, std::piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple())
1409	.first->second;	1509	.first->second;
1410	// NOLINTEND(bugprone-use-after-move)
1411	}	1510	}
1412		1511
1413	# else // _LIBCPP_CXX03_LANG	1512	# else // _LIBCPP_CXX03_LANG
...	@@ -1417,44 +1516,41 @@ typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder	...	@@ -1417,44 +1516,41 @@ typename map<_Key, _Tp, _Compare, _Allocator>::__node_holder
1417	map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k) {	1516	map<_Key, _Tp, _Compare, _Allocator>::__construct_node_with_key(const key_type& __k) {
1418	__node_allocator& __na = __tree_.__node_alloc();	1517	__node_allocator& __na = __tree_.__node_alloc();
1419	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));	1518	__node_holder __h(__node_traits::allocate(__na, 1), _Dp(__na));
1420	__node_traits::construct(__na, std::addressof(__h->__value_.first), __k);	1519	__node_traits::construct(__na, std::addressof(__h->__get_value().first), __k);
1421	__h.get_deleter().__first_constructed = true;	1520	__h.get_deleter().__first_constructed = true;
1422	__node_traits::construct(__na, std::addressof(__h->__value_.second));	1521	__node_traits::construct(__na, std::addressof(__h->__get_value().second));
1423	__h.get_deleter().__second_constructed = true;	1522	__h.get_deleter().__second_constructed = true;
1424	return __h;	1523	return __h;
1425	}	1524	}
1426		1525
1427	template <class _Key, class _Tp, class _Compare, class _Allocator>	1526	template <class _Key, class _Tp, class _Compare, class _Allocator>
1428	_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) {	1527	_Tp& map<_Key, _Tp, _Compare, _Allocator>::operator[](const key_type& __k) {
1429	__parent_pointer __parent;	1528	auto [__parent, __child] = __tree_.__find_equal(__k);
1430	__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);	1529	__node_pointer __r = static_cast<__node_pointer>(__child);
1431	__node_pointer __r = static_cast<__node_pointer>(__child);
1432	if (__child == nullptr) {	1530	if (__child == nullptr) {
1433	__node_holder __h = __construct_node_with_key(__k);	1531	__node_holder __h = __construct_node_with_key(__k);
1434	__tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));	1532	__tree_.__insert_node_at(__parent, __child, static_cast<__node_base_pointer>(__h.get()));
1435	__r = __h.release();	1533	__r = __h.release();
1436	}	1534	}
1437	return __r->__value_.second;	1535	return __r->__get_value().second;
1438	}	1536	}
1439		1537
1440	# endif // _LIBCPP_CXX03_LANG	1538	# endif // _LIBCPP_CXX03_LANG
1441		1539
1442	template <class _Key, class _Tp, class _Compare, class _Allocator>	1540	template <class _Key, class _Tp, class _Compare, class _Allocator>
1443	_Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) {	1541	_Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) {
1444	__parent_pointer __parent;	1542	auto [_, __child] = __tree_.__find_equal(__k);
1445	__node_base_pointer& __child = __tree_.__find_equal(__parent, __k);
1446	if (__child == nullptr)	1543	if (__child == nullptr)
1447	std::__throw_out_of_range("map::at: key not found");	1544	std::__throw_out_of_range("map::at: key not found");
1448	return static_cast<__node_pointer>(__child)->__value_.second;	1545	return static_cast<__node_pointer>(__child)->__get_value().second;
1449	}	1546	}
1450		1547
1451	template <class _Key, class _Tp, class _Compare, class _Allocator>	1548	template <class _Key, class _Tp, class _Compare, class _Allocator>
1452	const _Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const {	1549	const _Tp& map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const {
1453	__parent_pointer __parent;	1550	auto [_, __child] = __tree_.__find_equal(__k);
1454	__node_base_pointer __child = __tree_.__find_equal(__parent, __k);
1455	if (__child == nullptr)	1551	if (__child == nullptr)
1456	std::__throw_out_of_range("map::at: key not found");	1552	std::__throw_out_of_range("map::at: key not found");
1457	return static_cast<__node_pointer>(__child)->__value_.second;	1553	return static_cast<__node_pointer>(__child)->__get_value().second;
1458	}	1554	}
1459		1555
1460	template <class _Key, class _Tp, class _Compare, class _Allocator>	1556	template <class _Key, class _Tp, class _Compare, class _Allocator>
...	@@ -1637,22 +1733,17 @@ public:	...	@@ -1637,22 +1733,17 @@ public:
1637	: multimap(from_range, std::forward<_Range>(__range), key_compare(), __a) {}	1733	: multimap(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
1638	# endif	1734	# endif
1639		1735
1640	_LIBCPP_HIDE_FROM_ABI multimap(const multimap& __m)	1736	_LIBCPP_HIDE_FROM_ABI multimap(const multimap& __m) = default;
1641	: __tree_(__m.__tree_.value_comp(),
1642	__alloc_traits::select_on_container_copy_construction(__m.__tree_.__alloc())) {
1643	insert(__m.begin(), __m.end());
1644	}
1645		1737
1646	_LIBCPP_HIDE_FROM_ABI multimap& operator=(const multimap& __m) = default;	1738	_LIBCPP_HIDE_FROM_ABI multimap& operator=(const multimap& __m) = default;
1647		1739
1648	# ifndef _LIBCPP_CXX03_LANG	1740	# ifndef _LIBCPP_CXX03_LANG
1649		1741
1650	_LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m) noexcept(is_nothrow_move_constructible<__base>::value) = default;	1742	_LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m) = default;
1651		1743
1652	_LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m, const allocator_type& __a);	1744	_LIBCPP_HIDE_FROM_ABI multimap(multimap&& __m, const allocator_type& __a) : __tree_(std::move(__m.__tree_), __a) {}
1653		1745
1654	_LIBCPP_HIDE_FROM_ABI multimap&	1746	_LIBCPP_HIDE_FROM_ABI multimap& operator=(multimap&& __m) = default;
1655	operator=(multimap&& __m) noexcept(is_nothrow_move_assignable<__base>::value) = default;
1656		1747
1657	_LIBCPP_HIDE_FROM_ABI multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())	1748	_LIBCPP_HIDE_FROM_ABI multimap(initializer_list<value_type> __il, const key_compare& __comp = key_compare())
1658	: __tree_(__vc(__comp)) {	1749	: __tree_(__vc(__comp)) {
...	@@ -1671,7 +1762,8 @@ public:	...	@@ -1671,7 +1762,8 @@ public:
1671	# endif	1762	# endif
1672		1763
1673	_LIBCPP_HIDE_FROM_ABI multimap& operator=(initializer_list<value_type> __il) {	1764	_LIBCPP_HIDE_FROM_ABI multimap& operator=(initializer_list<value_type> __il) {
1674	__tree_.__assign_multi(__il.begin(), __il.end());	1765	clear();
		1766	insert(__il.begin(), __il.end());
1675	return *this;	1767	return *this;
1676	}	1768	}
1677		1769
...	@@ -1679,37 +1771,42 @@ public:	...	@@ -1679,37 +1771,42 @@ public:
1679		1771
1680	_LIBCPP_HIDE_FROM_ABI explicit multimap(const allocator_type& __a) : __tree_(typename __base::allocator_type(__a)) {}	1772	_LIBCPP_HIDE_FROM_ABI explicit multimap(const allocator_type& __a) : __tree_(typename __base::allocator_type(__a)) {}
1681		1773
1682	_LIBCPP_HIDE_FROM_ABI multimap(const multimap& __m, const allocator_type& __a)	1774	_LIBCPP_HIDE_FROM_ABI multimap(const multimap& __m, const allocator_type& __a) : __tree_(__m.__tree_, __a) {}
1683	: __tree_(__m.__tree_.value_comp(), typename __base::allocator_type(__a)) {
1684	insert(__m.begin(), __m.end());
1685	}
1686		1775
1687	_LIBCPP_HIDE_FROM_ABI ~multimap() {	1776	_LIBCPP_HIDE_FROM_ABI ~multimap() {
1688	static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), "");	1777	static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), "");
1689	}	1778	}
1690		1779
1691	_LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }	1780	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
1692	_LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }	1781	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
1693	_LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }	1782	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
1694	_LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }	1783	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
1695		1784
1696	_LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }	1785	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
1697	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }	1786	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
1698	_LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }	1787	return const_reverse_iterator(end());
1699	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }	1788	}
		1789	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
		1790	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
		1791	return const_reverse_iterator(begin());
		1792	}
1700		1793
1701	_LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }	1794	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
1702	_LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }	1795	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
1703	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }	1796	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
1704	_LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }	1797	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
1705		1798
1706	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }	1799	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
1707	_LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }	1800	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
1708	_LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }	1801	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
1709		1802
1710	_LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return allocator_type(__tree_.__alloc()); }	1803	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
1711	_LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp().key_comp(); }	1804	return allocator_type(__tree_.__alloc());
1712	_LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return value_compare(__tree_.value_comp().key_comp()); }	1805	}
		1806	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp().key_comp(); }
		1807	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const {
		1808	return value_compare(__tree_.value_comp().key_comp());
		1809	}
1713		1810
1714	# ifndef _LIBCPP_CXX03_LANG	1811	# ifndef _LIBCPP_CXX03_LANG
1715		1812
...	@@ -1751,17 +1848,13 @@ public:	...	@@ -1751,17 +1848,13 @@ public:
1751		1848
1752	template <class _InputIterator>	1849	template <class _InputIterator>
1753	_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {	1850	_LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
1754	for (const_iterator __e = cend(); __f != __l; ++__f)	1851	__tree_.__insert_range_multi(__f, __l);
1755	__tree_.__emplace_hint_multi(__e.__i_, *__f);
1756	}	1852	}
1757		1853
1758	# if _LIBCPP_STD_VER >= 23	1854	# if _LIBCPP_STD_VER >= 23
1759	template <_ContainerCompatibleRange<value_type> _Range>	1855	template <_ContainerCompatibleRange<value_type> _Range>
1760	_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {	1856	_LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
1761	const_iterator __end = cend();	1857	__tree_.__insert_range_multi(ranges::begin(__range), ranges::end(__range));
1762	for (auto&& __element : __range) {
1763	__tree_.__emplace_hint_multi(__end.__i_, std::forward<decltype(__element)>(__element));
1764	}
1765	}	1858	}
1766	# endif	1859	# endif
1767		1860
...	@@ -1783,10 +1876,10 @@ public:	...	@@ -1783,10 +1876,10 @@ public:
1783	"node_type with incompatible allocator passed to multimap::insert()");	1876	"node_type with incompatible allocator passed to multimap::insert()");
1784	return __tree_.template __node_handle_insert_multi<node_type>(__hint.__i_, std::move(__nh));	1877	return __tree_.template __node_handle_insert_multi<node_type>(__hint.__i_, std::move(__nh));
1785	}	1878	}
1786	_LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {	1879	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
1787	return __tree_.template __node_handle_extract<node_type>(__key);	1880	return __tree_.template __node_handle_extract<node_type>(__key);
1788	}	1881	}
1789	_LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {	1882	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
1790	return __tree_.template __node_handle_extract<node_type>(__it.__i_);	1883	return __tree_.template __node_handle_extract<node_type>(__it.__i_);
1791	}	1884	}
1792	template <class _Compare2>	1885	template <class _Compare2>
...	@@ -1821,75 +1914,89 @@ public:	...	@@ -1821,75 +1914,89 @@ public:
1821	__tree_.swap(__m.__tree_);	1914	__tree_.swap(__m.__tree_);
1822	}	1915	}
1823		1916
1824	_LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }	1917	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
1825	_LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }	1918	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
1826	# if _LIBCPP_STD_VER >= 14	1919	# if _LIBCPP_STD_VER >= 14
1827	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1920	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1828	_LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {	1921	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
1829	return __tree_.find(__k);	1922	return __tree_.find(__k);
1830	}	1923	}
1831	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1924	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1832	_LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {	1925	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
1833	return __tree_.find(__k);	1926	return __tree_.find(__k);
1834	}	1927	}
1835	# endif	1928	# endif
1836		1929
1837	_LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_multi(__k); }	1930	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
		1931	return __tree_.__count_multi(__k);
		1932	}
1838	# if _LIBCPP_STD_VER >= 14	1933	# if _LIBCPP_STD_VER >= 14
1839	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1934	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1840	_LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {	1935	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
1841	return __tree_.__count_multi(__k);	1936	return __tree_.__count_multi(__k);
1842	}	1937	}
1843	# endif	1938	# endif
1844		1939
1845	# if _LIBCPP_STD_VER >= 20	1940	# if _LIBCPP_STD_VER >= 20
1846	_LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }	1941	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
1847	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1942	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1848	_LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {	1943	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
1849	return find(__k) != end();	1944	return find(__k) != end();
1850	}	1945	}
1851	# endif // _LIBCPP_STD_VER >= 20	1946	# endif // _LIBCPP_STD_VER >= 20
1852		1947
1853	_LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }	1948	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) {
1854	_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }	1949	return __tree_.__lower_bound_multi(__k);
		1950	}
		1951
		1952	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const {
		1953	return __tree_.__lower_bound_multi(__k);
		1954	}
		1955
1855	# if _LIBCPP_STD_VER >= 14	1956	# if _LIBCPP_STD_VER >= 14
1856	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1957	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1857	_LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {	1958	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
1858	return __tree_.lower_bound(__k);	1959	return __tree_.__lower_bound_multi(__k);
1859	}	1960	}
1860		1961
1861	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1962	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1862	_LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {	1963	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
1863	return __tree_.lower_bound(__k);	1964	return __tree_.__lower_bound_multi(__k);
1864	}	1965	}
1865	# endif	1966	# endif
1866		1967
1867	_LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }	1968	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) {
1868	_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }	1969	return __tree_.__upper_bound_multi(__k);
		1970	}
		1971
		1972	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const {
		1973	return __tree_.__upper_bound_multi(__k);
		1974	}
		1975
1869	# if _LIBCPP_STD_VER >= 14	1976	# if _LIBCPP_STD_VER >= 14
1870	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1977	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1871	_LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {	1978	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
1872	return __tree_.upper_bound(__k);	1979	return __tree_.__upper_bound_multi(__k);
1873	}	1980	}
1874	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1981	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1875	_LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {	1982	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
1876	return __tree_.upper_bound(__k);	1983	return __tree_.__upper_bound_multi(__k);
1877	}	1984	}
1878	# endif	1985	# endif
1879		1986
1880	_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {	1987	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
1881	return __tree_.__equal_range_multi(__k);	1988	return __tree_.__equal_range_multi(__k);
1882	}	1989	}
1883	_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {	1990	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
1884	return __tree_.__equal_range_multi(__k);	1991	return __tree_.__equal_range_multi(__k);
1885	}	1992	}
1886	# if _LIBCPP_STD_VER >= 14	1993	# if _LIBCPP_STD_VER >= 14
1887	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1994	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1888	_LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {	1995	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
1889	return __tree_.__equal_range_multi(__k);	1996	return __tree_.__equal_range_multi(__k);
1890	}	1997	}
1891	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>	1998	template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
1892	_LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {	1999	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
1893	return __tree_.__equal_range_multi(__k);	2000	return __tree_.__equal_range_multi(__k);
1894	}	2001	}
1895	# endif	2002	# endif
...	@@ -1901,6 +2008,8 @@ private:	...	@@ -1901,6 +2008,8 @@ private:
1901		2008
1902	typedef __map_node_destructor<__node_allocator> _Dp;	2009	typedef __map_node_destructor<__node_allocator> _Dp;
1903	typedef unique_ptr<__node, _Dp> __node_holder;	2010	typedef unique_ptr<__node, _Dp> __node_holder;
		2011
		2012	friend struct __specialized_algorithm<_Algorithm::__for_each, __single_range<multimap> >;
1904	};	2013	};
1905		2014
1906	# if _LIBCPP_STD_VER >= 17	2015	# if _LIBCPP_STD_VER >= 17
...	@@ -1908,8 +2017,8 @@ template <class _InputIterator,	...	@@ -1908,8 +2017,8 @@ template <class _InputIterator,
1908	class _Compare = less<__iter_key_type<_InputIterator>>,	2017	class _Compare = less<__iter_key_type<_InputIterator>>,
1909	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,	2018	class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
1910	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,	2019	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
1911	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	2020	class = enable_if_t<!__is_allocator_v<_Compare>>,
1912	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2021	class = enable_if_t<__is_allocator_v<_Allocator>>>
1913	multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())	2022	multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
1914	-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;	2023	-> multimap<__iter_key_type<_InputIterator>, __iter_mapped_type<_InputIterator>, _Compare, _Allocator>;
1915		2024
...	@@ -1917,8 +2026,8 @@ multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Al	...	@@ -1917,8 +2026,8 @@ multimap(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Al
1917	template <ranges::input_range _Range,	2026	template <ranges::input_range _Range,
1918	class _Compare = less<__range_key_type<_Range>>,	2027	class _Compare = less<__range_key_type<_Range>>,
1919	class _Allocator = allocator<__range_to_alloc_type<_Range>>,	2028	class _Allocator = allocator<__range_to_alloc_type<_Range>>,
1920	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	2029	class = enable_if_t<!__is_allocator_v<_Compare>>,
1921	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2030	class = enable_if_t<__is_allocator_v<_Allocator>>>
1922	multimap(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())	2031	multimap(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
1923	-> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;	2032	-> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, _Compare, _Allocator>;
1924	# endif	2033	# endif
...	@@ -1927,16 +2036,15 @@ template <class _Key,	...	@@ -1927,16 +2036,15 @@ template <class _Key,
1927	class _Tp,	2036	class _Tp,
1928	class _Compare = less<remove_const_t<_Key>>,	2037	class _Compare = less<remove_const_t<_Key>>,
1929	class _Allocator = allocator<pair<const _Key, _Tp>>,	2038	class _Allocator = allocator<pair<const _Key, _Tp>>,
1930	class = enable_if_t<!__is_allocator<_Compare>::value, void>,	2039	class = enable_if_t<!__is_allocator_v<_Compare>>,
1931	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2040	class = enable_if_t<__is_allocator_v<_Allocator>>>
1932	multimap(initializer_list<pair<_Key, _Tp>>,	2041	multimap(initializer_list<pair<_Key, _Tp>>, _Compare = _Compare(), _Allocator = _Allocator())
1933	_Compare = _Compare(),	2042	-> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
1934	_Allocator = _Allocator()) -> multimap<remove_const_t<_Key>, _Tp, _Compare, _Allocator>;
1935		2043
1936	template <class _InputIterator,	2044	template <class _InputIterator,
1937	class _Allocator,	2045	class _Allocator,
1938	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,	2046	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
1939	class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2047	class = enable_if_t<__is_allocator_v<_Allocator>>>
1940	multimap(_InputIterator, _InputIterator, _Allocator)	2048	multimap(_InputIterator, _InputIterator, _Allocator)
1941	-> multimap<__iter_key_type<_InputIterator>,	2049	-> multimap<__iter_key_type<_InputIterator>,
1942	__iter_mapped_type<_InputIterator>,	2050	__iter_mapped_type<_InputIterator>,
...	@@ -1944,26 +2052,30 @@ multimap(_InputIterator, _InputIterator, _Allocator)	...	@@ -1944,26 +2052,30 @@ multimap(_InputIterator, _InputIterator, _Allocator)
1944	_Allocator>;	2052	_Allocator>;
1945		2053
1946	# if _LIBCPP_STD_VER >= 23	2054	# if _LIBCPP_STD_VER >= 23
1947	template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2055	template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
1948	multimap(from_range_t, _Range&&, _Allocator)	2056	multimap(from_range_t, _Range&&, _Allocator)
1949	-> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;	2057	-> multimap<__range_key_type<_Range>, __range_mapped_type<_Range>, less<__range_key_type<_Range>>, _Allocator>;
1950	# endif	2058	# endif
1951		2059
1952	template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>	2060	template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
1953	multimap(initializer_list<pair<_Key, _Tp>>,	2061	multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
1954	_Allocator) -> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;	2062	-> multimap<remove_const_t<_Key>, _Tp, less<remove_const_t<_Key>>, _Allocator>;
1955	# endif	2063	# endif
1956		2064
1957	# ifndef _LIBCPP_CXX03_LANG	2065	# if _LIBCPP_STD_VER >= 14
1958	template <class _Key, class _Tp, class _Compare, class _Allocator>	2066	template <class _Key, class _Tp, class _Compare, class _Allocator>
1959	multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)	2067	struct __specialized_algorithm<_Algorithm::__for_each, __single_range<multimap<_Key, _Tp, _Compare, _Allocator>>> {
1960	: __tree_(std::move(__m.__tree_), typename __base::allocator_type(__a)) {	2068	using __map _LIBCPP_NODEBUG = multimap<_Key, _Tp, _Compare, _Allocator>;
1961	if (__a != __m.get_allocator()) {	2069
1962	const_iterator __e = cend();	2070	static const bool __has_algorithm = true;
1963	while (!__m.empty())	2071
1964	__tree_.__insert_multi_from_orphaned_node(__e.__i_, std::move(__m.__tree_.remove(__m.begin().__i_)->__value_));	2072	template <class _Map, class _Func, class _Proj>
		2073	_LIBCPP_HIDE_FROM_ABI static auto operator()(_Map&& __map, _Func __func, _Proj __proj) {
		2074	auto [_, __func2] = __specialized_algorithm<_Algorithm::__for_each, __single_range<typename __map::__base>>()(
		2075	__map.__tree_, std::move(__func), std::move(__proj));
		2076	return std::make_pair(__map.end(), std::move(__func2));
1965	}	2077	}
1966	}	2078	};
1967	# endif	2079	# endif
1968		2080
1969	template <class _Key, class _Tp, class _Compare, class _Allocator>	2081	template <class _Key, class _Tp, class _Compare, class _Allocator>

lib/libcxx/include/math.h+19

...	@@ -429,6 +429,25 @@ using std::__math::isnormal;	...	@@ -429,6 +429,25 @@ using std::__math::isnormal;
429	using std::__math::isunordered;	429	using std::__math::isunordered;
430	# endif // _LIBCPP_MSVCRT	430	# endif // _LIBCPP_MSVCRT
431		431
		432	# if defined(_LIBCPP_MSVCRT) && _LIBCPP_STD_VER >= 20
		433	// MS UCRT incorrectly defines some functions in a way not working with integer types. Until C++20, this was worked
		434	// around by -fdelayed-template-parsing. Since C++20, we can use standard feature "requires" instead.
		435
		436	// TODO: Remove the workaround once UCRT fixes these functions. Note that this doesn't seem planned as of 2025-07 per
		437	// https://developercommunity.visualstudio.com/t/10294165.
		438
		439	using std::__math::__ucrt::isfinite;
		440	using std::__math::__ucrt::isgreater;
		441	using std::__math::__ucrt::isgreaterequal;
		442	using std::__math::__ucrt::isinf;
		443	using std::__math::__ucrt::isless;
		444	using std::__math::__ucrt::islessequal;
		445	using std::__math::__ucrt::islessgreater;
		446	using std::__math::__ucrt::isnan;
		447	using std::__math::__ucrt::isnormal;
		448	using std::__math::__ucrt::isunordered;
		449	# endif // defined(_LIBCPP_MSVCRT) && _LIBCPP_STD_VER >= 20
		450
432	// We have to provide double overloads for <math.h> to work on platforms that don't provide the full set of math	451	// We have to provide double overloads for <math.h> to work on platforms that don't provide the full set of math
433	// functions. To make the overload set work with multiple functions that take the same arguments, we make our overloads	452	// functions. To make the overload set work with multiple functions that take the same arguments, we make our overloads
434	// templates. Functions are preferred over function templates during overload resolution, which means that our overload	453	// templates. Functions are preferred over function templates during overload resolution, which means that our overload

lib/libcxx/include/mdspan+1-5

 @@ -450,11 +450,7 @@ namespace std {
 #  include <__config>
 #  if _LIBCPP_STD_VER >= 23
-#    include <__fwd/mdspan.h> // TODO(boomanaiden154): This is currently a
+#    include <__fwd/mdspan.h>
-                              // non-standard extension to include
-                              // std::dynamic_extent tracked by LWG issue 4275.
-                              // This comment should be deleted or the include
-                              // deleted upon resolution.
 #    include <__fwd/span.h>
 #    include <__mdspan/default_accessor.h>
 #    include <__mdspan/extents.h>

lib/libcxx/include/mutex+29-19

 @@ -229,12 +229,12 @@ public:
   recursive_mutex& operator=(const recursive_mutex&) = delete;
   void lock();
-  bool try_lock() _NOEXCEPT;
+  [[__nodiscard__]] bool try_lock() _NOEXCEPT;
   void unlock() _NOEXCEPT;
   typedef __libcpp_recursive_mutex_t* native_handle_type;
-  _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI native_handle_type native_handle() { return &__m_; }
 };
 class _LIBCPP_EXPORTED_FROM_ABI timed_mutex {
 @@ -251,14 +251,14 @@ public:
 public:
   void lock();
-  bool try_lock() _NOEXCEPT;
+  [[__nodiscard__]] bool try_lock() _NOEXCEPT;
   template <class _Rep, class _Period>
-  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
     return try_lock_until(chrono::steady_clock::now() + __d);
   }
   template <class _Clock, class _Duration>
-  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
     using namespace chrono;
     unique_lock<mutex> __lk(__m_);
     bool __no_timeout = _Clock::now() < __t;
 @@ -288,14 +288,14 @@ public:
   recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
   void lock();
-  bool try_lock() _NOEXCEPT;
+  [[__nodiscard__]] bool try_lock() _NOEXCEPT;
   template <class _Rep, class _Period>
-  _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_for(const chrono::duration<_Rep, _Period>& __d) {
     return try_lock_until(chrono::steady_clock::now() + __d);
   }
   template <class _Clock, class _Duration>
-  _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t) {
     using namespace chrono;
     __thread_id __id = this_thread::get_id();
     unique_lock<mutex> __lk(__m_);
 @@ -320,7 +320,7 @@ public:
 };
 template <class _L0, class _L1>
-_LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) {
+[[__nodiscard__]] _LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) {
   unique_lock<_L0> __u0(__l0, try_to_lock_t());
   if (__u0.owns_lock()) {
     if (__l1.try_lock()) {
 @@ -335,7 +335,8 @@ _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1) {
 #    ifndef _LIBCPP_CXX03_LANG
 template <class _L0, class _L1, class _L2, class... _L3>
-_LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+[[__nodiscard__]] _LIBCPP_NO_THREAD_SAFETY_ANALYSIS
+    _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
   int __r = 0;
   unique_lock<_L0> __u0(__l0, try_to_lock);
   if (__u0.owns_lock()) {
 @@ -350,8 +351,11 @@ _LIBCPP_HIDE_FROM_ABI int try_lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3
 #    endif // _LIBCPP_CXX03_LANG
+// We're using unique_lock to implement the functions, which thread annotations don't support. So we have to disable
+// the analysis inside the function.
 template <class _L0, class _L1>
-_LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1) {
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1)
+    _LIBCPP_ACQUIRE_CAPABILITY(__l0, __l1) {
   while (true) {
     {
       unique_lock<_L0> __u0(__l0);
 @@ -375,7 +379,7 @@ _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1) {
 #    ifndef _LIBCPP_CXX03_LANG
 template <class _L0, class _L1, class _L2, class... _L3>
-void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
   while (true) {
     switch (__i) {
     case 0: {
 @@ -410,8 +414,14 @@ void __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
   }
 }
+// We're using unique_lock to implement the functions, which thread annotations don't support. So we have to disable
+// the analysis inside the function.
 template <class _L0, class _L1, class _L2, class... _L3>
-inline _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3) {
+_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI void lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3&... __l3)
+#      if defined(_LIBCPP_CLANG_VER) && _LIBCPP_CLANG_VER >= 2101
+    _LIBCPP_ACQUIRE_CAPABILITY(__l0, __l1, __l2, __l3...)
+#      endif
+{
   std::__lock_first(0, __l0, __l1, __l2, __l3...);
 }
 @@ -469,17 +479,14 @@ public:
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI scoped_lock(adopt_lock_t, _MArgs&... __margs) : __t_(__margs...) {}
-  _LIBCPP_HIDE_FROM_ABI ~scoped_lock() {
+  _LIBCPP_HIDE_FROM_ABI ~scoped_lock() { __unlock_unpack(make_index_sequence<sizeof...(_MArgs)>(), __t_); }
-    typedef typename __make_tuple_indices<sizeof...(_MArgs)>::type _Indices;
-    __unlock_unpack(_Indices{}, __t_);
-  }
   scoped_lock(scoped_lock const&)            = delete;
   scoped_lock& operator=(scoped_lock const&) = delete;
 private:
   template <size_t... _Indx>
-  _LIBCPP_HIDE_FROM_ABI static void __unlock_unpack(__tuple_indices<_Indx...>, _MutexTuple& __mt) {
+  _LIBCPP_HIDE_FROM_ABI static void __unlock_unpack(index_sequence<_Indx...>, _MutexTuple& __mt) {
     (std::get<_Indx>(__mt).unlock(), ...);
   }
 @@ -494,6 +501,10 @@ _LIBCPP_END_NAMESPACE_STD
 _LIBCPP_POP_MACROS
+#  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 23
+#    include <typeinfo>
+#  endif
 #  if !defined(_LIBCPP_REMOVE_TRANSITIVE_INCLUDES) && _LIBCPP_STD_VER <= 20
 #    include <atomic>
 #    include <concepts>
 @@ -507,7 +518,6 @@ _LIBCPP_POP_MACROS
 #    include <stdexcept>
 #    include <system_error>
 #    include <type_traits>
-#    include <typeinfo>
 #  endif
 #endif // __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)

lib/libcxx/include/optional+644-149

 @@ -20,6 +20,11 @@ namespace std {
   template <class T>
     class optional;
+  template<class T>
+   constexpr bool ranges::enable_view<optional<T>> = true;
+  template<class T>
+   constexpr auto format_kind<optional<T>> = range_format::disabled;
   template<class T>
     concept is-derived-from-optional = requires(const T& t) {       // exposition only
       []<class U>(const optional<U>&){ }(t);
 @@ -102,6 +107,8 @@ namespace std {
   class optional {
   public:
     using value_type = T;
+    using iterator               = implementation-defined; // see [optional.iterators]
+    using const_iterator         = implementation-defined; // see [optional.iterators]
     // [optional.ctor], constructors
     constexpr optional() noexcept;
 @@ -112,7 +119,7 @@ namespace std {
       constexpr explicit optional(in_place_t, Args &&...);
     template<class U, class... Args>
       constexpr explicit optional(in_place_t, initializer_list<U>, Args &&...);
-    template<class U = T>
+    template<class U = remove_cv_t<T>>
       constexpr explicit(see-below) optional(U &&);
     template<class U>
       explicit(see-below) optional(const optional<U> &);                          // constexpr in C++20
 @@ -126,7 +133,7 @@ namespace std {
     optional &operator=(nullopt_t) noexcept;                                      // constexpr in C++20
     constexpr optional &operator=(const optional &);
     constexpr optional &operator=(optional &&) noexcept(see below);
-    template<class U = T> optional &operator=(U &&);                              // constexpr in C++20
+    template<class U = remove_cv_t<T>> optional &operator=(U &&);                              // constexpr in C++20
     template<class U> optional &operator=(const optional<U> &);                   // constexpr in C++20
     template<class U> optional &operator=(optional<U> &&);                        // constexpr in C++20
     template<class... Args> T& emplace(Args &&...);                               // constexpr in C++20
 @@ -135,6 +142,12 @@ namespace std {
     // [optional.swap], swap
     void swap(optional &) noexcept(see below ); // constexpr in C++20
+    // [optional.iterators], iterator support
+    constexpr iterator begin() noexcept;
+    constexpr const_iterator begin() const noexcept;
+    constexpr iterator end() noexcept;
+    constexpr const_iterator end() const noexcept;
     // [optional.observe], observers
     constexpr T const *operator->() const noexcept;
     constexpr T *operator->() noexcept;
 @@ -148,8 +161,8 @@ namespace std {
     constexpr T &value() &;
     constexpr T &&value() &&;
     constexpr const T &&value() const &&;
-    template<class U> constexpr T value_or(U &&) const &;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U &&) const &;
-    template<class U> constexpr T value_or(U &&) &&;
+    template<class U = remove_cv_t<T>> constexpr T value_or(U &&) &&;
     // [optional.monadic], monadic operations
     template<class F> constexpr auto and_then(F&& f) &;         // since C++23
 @@ -173,6 +186,71 @@ namespace std {
   template<class T>
     optional(T) -> optional<T>;
+  template<class T>
+  class optional<T&> { // since C++26
+  public:
+    using value_type     = T;
+    using iterator       = implementation-defined;              // see [optional.ref.iterators]
+  public:
+    // [optional.ref.ctor], constructors
+    constexpr optional() noexcept = default;
+    constexpr optional(nullopt_t) noexcept : optional() {}
+    constexpr optional(const optional& rhs) noexcept = default;
+    template<class Arg>
+      constexpr explicit optional(in_place_t, Arg&& arg);
+    template<class U>
+      constexpr explicit(see below) optional(U&& u) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(optional<U>& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(const optional<U>& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(optional<U>&& rhs) noexcept(see below);
+    template<class U>
+      constexpr explicit(see below) optional(const optional<U>&& rhs) noexcept(see below);
+    constexpr ~optional() = default;
+    // [optional.ref.assign], assignment
+    constexpr optional& operator=(nullopt_t) noexcept;
+    constexpr optional& operator=(const optional& rhs) noexcept = default;
+    template<class U> constexpr T& emplace(U&& u) noexcept(see below);
+    // [optional.ref.swap], swap
+    constexpr void swap(optional& rhs) noexcept;
+    // [optional.ref.iterators], iterator support
+    constexpr iterator begin() const noexcept;
+    constexpr iterator end() const noexcept;
+    // [optional.ref.observe], observers
+    constexpr T*       operator->() const noexcept;
+    constexpr T&       operator*() const noexcept;
+    constexpr explicit operator bool() const noexcept;
+    constexpr bool     has_value() const noexcept;
+    constexpr T&       value() const;                           // freestanding-deleted
+    template<class U = remove_cv_t<T>>
+      constexpr remove_cv_t<T> value_or(U&& u) const;
+    // [optional.ref.monadic], monadic operations
+    template<class F> constexpr auto and_then(F&& f) const;
+    template<class F> constexpr optional<invoke_result_t<F, T&>> transform(F&& f) const;
+    template<class F> constexpr optional or_else(F&& f) const;
+    // [optional.ref.mod], modifiers
+    constexpr void reset() noexcept;
+  private:
+    T* val = nullptr;                                           // exposition only
+    // [optional.ref.expos], exposition only helper functions
+    template<class U>
+      constexpr void convert-ref-init-val(U&& u);               // exposition only
+  };
 } // namespace std
 */
 @@ -186,13 +264,19 @@ namespace std {
 #  include <__compare/three_way_comparable.h>
 #  include <__concepts/invocable.h>
 #  include <__config>
+#  include <__cstddef/ptrdiff_t.h>
 #  include <__exception/exception.h>
+#  include <__format/range_format.h>
 #  include <__functional/hash.h>
 #  include <__functional/invoke.h>
 #  include <__functional/unary_function.h>
 #  include <__fwd/functional.h>
+#  include <__iterator/bounded_iter.h>
+#  include <__iterator/wrap_iter.h>
 #  include <__memory/addressof.h>
 #  include <__memory/construct_at.h>
+#  include <__ranges/enable_borrowed_range.h>
+#  include <__ranges/enable_view.h>
 #  include <__tuple/sfinae_helpers.h>
 #  include <__type_traits/add_pointer.h>
 #  include <__type_traits/conditional.h>
 @@ -200,6 +284,7 @@ namespace std {
 #  include <__type_traits/decay.h>
 #  include <__type_traits/disjunction.h>
 #  include <__type_traits/enable_if.h>
+#  include <__type_traits/integral_constant.h>
 #  include <__type_traits/invoke.h>
 #  include <__type_traits/is_array.h>
 #  include <__type_traits/is_assignable.h>
 @@ -207,11 +292,11 @@ namespace std {
 #  include <__type_traits/is_convertible.h>
 #  include <__type_traits/is_core_convertible.h>
 #  include <__type_traits/is_destructible.h>
+#  include <__type_traits/is_function.h>
 #  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
 #  include <__type_traits/is_object.h>
 #  include <__type_traits/is_reference.h>
-#  include <__type_traits/is_replaceable.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_scalar.h>
 #  include <__type_traits/is_swappable.h>
 @@ -220,6 +305,7 @@ namespace std {
 #  include <__type_traits/is_trivially_destructible.h>
 #  include <__type_traits/is_trivially_relocatable.h>
 #  include <__type_traits/negation.h>
+#  include <__type_traits/reference_constructs_from_temporary.h>
 #  include <__type_traits/remove_const.h>
 #  include <__type_traits/remove_cv.h>
 #  include <__type_traits/remove_cvref.h>
 @@ -255,7 +341,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bad_optional_access& operator=(const bad_optional_access&) _NOEXCEPT = default;
   // Get the key function ~bad_optional_access() into the dylib
   ~bad_optional_access() _NOEXCEPT override;
-  const char* what() const _NOEXCEPT override;
+  [[__nodiscard__]] const char* what() const _NOEXCEPT override;
 };
 } // namespace std
 @@ -358,7 +444,7 @@ struct __optional_storage_base : __optional_destruct_base<_Tp> {
   using value_type             = _Tp;
   using __base::__base;
-  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__engaged_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return this->__engaged_; }
   _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() & noexcept { return this->__val_; }
   _LIBCPP_HIDE_FROM_ABI constexpr const value_type& __get() const& noexcept { return this->__val_; }
 @@ -390,58 +476,60 @@ struct __optional_storage_base : __optional_destruct_base<_Tp> {
         __construct(std::forward<_That>(__opt).__get());
     }
   }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  __swap(__optional_storage_base& __rhs) noexcept(is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>) {
+    using std::swap;
+    if (this->has_value() == __rhs.has_value()) {
+      if (this->has_value())
+        swap(this->__get(), __rhs.__get());
+    } else {
+      if (this->has_value()) {
+        __rhs.__construct(std::move(this->__get()));
+        this->reset();
+      } else {
+        this->__construct(std::move(__rhs.__get()));
+        __rhs.reset();
+      }
+    }
+  }
 };
-// optional<T&> is currently required to be ill-formed. However, it may
-// be allowed in the future. For this reason, it has already been implemented
-// to ensure we can make the change in an ABI-compatible manner.
 template <class _Tp>
 struct __optional_storage_base<_Tp, true> {
   using value_type                 = _Tp;
   using __raw_type _LIBCPP_NODEBUG = remove_reference_t<_Tp>;
   __raw_type* __value_;
+  _LIBCPP_HIDE_FROM_ABI constexpr __optional_storage_base() noexcept : __value_(nullptr) {}
   template <class _Up>
-  static _LIBCPP_HIDE_FROM_ABI constexpr bool __can_bind_reference() {
+  _LIBCPP_HIDE_FROM_ABI constexpr void __convert_init_ref_val(_Up&& __val) noexcept {
-    using _RawUp = __libcpp_remove_reference_t<_Up>;
+    _Tp& __r(std::forward<_Up>(__val));
-    using _UpPtr = _RawUp*;
+    __value_ = std::addressof(__r);
-    using _RawTp = __libcpp_remove_reference_t<_Tp>;
-    using _TpPtr = _RawTp*;
-    using _CheckLValueArg =
-        integral_constant<bool,
-                          (is_lvalue_reference<_Up>::value && is_convertible<_UpPtr, _TpPtr>::value) ||
-                              is_same<_RawUp, reference_wrapper<_RawTp>>::value ||
-                              is_same<_RawUp, reference_wrapper<__remove_const_t<_RawTp>>>::value >;
-    return (is_lvalue_reference<_Tp>::value && _CheckLValueArg::value) ||
-           (is_rvalue_reference<_Tp>::value && !is_lvalue_reference<_Up>::value &&
-            is_convertible<_UpPtr, _TpPtr>::value);
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr __optional_storage_base() noexcept : __value_(nullptr) {}
   template <class _UArg>
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg)
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit __optional_storage_base(in_place_t, _UArg&& __uarg) {
-      : __value_(std::addressof(__uarg)) {
+    static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
-    static_assert(__can_bind_reference<_UArg>(),
+                  "Attempted to construct a reference element in optional from a "
-                  "Attempted to construct a reference element in tuple from a "
                   "possible temporary");
+    __convert_init_ref_val(std::forward<_UArg>(__uarg));
   }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void reset() noexcept { __value_ = nullptr; }
-  _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool has_value() const noexcept { return __value_ != nullptr; }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() const& noexcept { return *__value_; }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& __get() const&& noexcept { return std::forward<value_type>(*__value_); }
+  _LIBCPP_HIDE_FROM_ABI constexpr value_type& __get() const noexcept { return *__value_; }
   template <class _UArg>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __construct(_UArg&& __val) {
     _LIBCPP_ASSERT_INTERNAL(!has_value(), "__construct called for engaged __optional_storage");
-    static_assert(__can_bind_reference<_UArg>(),
+    static_assert(!__reference_constructs_from_temporary_v<_Tp, _UArg>,
                   "Attempted to construct a reference element in tuple from a "
                   "possible temporary");
-    __value_ = std::addressof(__val);
+    __convert_init_ref_val(std::forward<_UArg>(__val));
   }
   template <class _That>
 @@ -462,9 +550,13 @@ struct __optional_storage_base<_Tp, true> {
         __construct(std::forward<_That>(__opt).__get());
     }
   }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __swap(__optional_storage_base& __rhs) noexcept {
+    std::swap(__value_, __rhs.__value_);
+  }
 };
-template <class _Tp, bool = is_trivially_copy_constructible<_Tp>::value>
+template <class _Tp, bool = is_trivially_copy_constructible_v<_Tp> || is_lvalue_reference_v<_Tp>>
 struct __optional_copy_base : __optional_storage_base<_Tp> {
   using __optional_storage_base<_Tp>::__optional_storage_base;
 };
 @@ -484,7 +576,7 @@ struct __optional_copy_base<_Tp, false> : __optional_storage_base<_Tp> {
   _LIBCPP_HIDE_FROM_ABI __optional_copy_base& operator=(__optional_copy_base&&)      = default;
 };
-template <class _Tp, bool = is_trivially_move_constructible<_Tp>::value>
+template <class _Tp, bool = is_trivially_move_constructible_v<_Tp> || is_lvalue_reference_v<_Tp>>
 struct __optional_move_base : __optional_copy_base<_Tp> {
   using __optional_copy_base<_Tp>::__optional_copy_base;
 };
 @@ -507,8 +599,9 @@ struct __optional_move_base<_Tp, false> : __optional_copy_base<_Tp> {
 };
 template <class _Tp,
-          bool = is_trivially_destructible<_Tp>::value && is_trivially_copy_constructible<_Tp>::value &&
+          bool = (is_trivially_destructible_v<_Tp> && is_trivially_copy_constructible_v<_Tp> &&
-                 is_trivially_copy_assignable<_Tp>::value>
+                  is_trivially_copy_assignable_v<_Tp>) ||
+                 is_lvalue_reference_v<_Tp>>
 struct __optional_copy_assign_base : __optional_move_base<_Tp> {
   using __optional_move_base<_Tp>::__optional_move_base;
 };
 @@ -531,8 +624,9 @@ struct __optional_copy_assign_base<_Tp, false> : __optional_move_base<_Tp> {
 };
 template <class _Tp,
-          bool = is_trivially_destructible<_Tp>::value && is_trivially_move_constructible<_Tp>::value &&
+          bool = (is_trivially_destructible_v<_Tp> && is_trivially_move_constructible_v<_Tp> &&
-                 is_trivially_move_assignable<_Tp>::value>
+                  is_trivially_move_assignable_v<_Tp>) ||
+                 is_lvalue_reference_v<_Tp>>
 struct __optional_move_assign_base : __optional_copy_assign_base<_Tp> {
   using __optional_copy_assign_base<_Tp>::__optional_copy_assign_base;
 };
 @@ -561,12 +655,24 @@ using __optional_sfinae_ctor_base_t _LIBCPP_NODEBUG =
 template <class _Tp>
 using __optional_sfinae_assign_base_t _LIBCPP_NODEBUG =
-    __sfinae_assign_base< (is_copy_constructible<_Tp>::value && is_copy_assignable<_Tp>::value),
+    __sfinae_assign_base< (is_copy_constructible_v<_Tp> && is_copy_assignable_v<_Tp>) || is_lvalue_reference_v<_Tp>,
-                          (is_move_constructible<_Tp>::value && is_move_assignable<_Tp>::value) >;
+                          (is_move_constructible_v<_Tp> && is_move_assignable_v<_Tp>) || is_lvalue_reference_v<_Tp>>;
 template <class _Tp>
 class optional;
+#    if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
+template <class _Tp>
+constexpr bool ranges::enable_view<optional<_Tp>> = true;
+template <class _Tp>
+constexpr range_format format_kind<optional<_Tp>> = range_format::disabled;
+template <class _Tp>
+constexpr bool ranges::enable_borrowed_range<optional<_Tp&>> = true;
+#    endif
 #    if _LIBCPP_STD_VER >= 20
 template <class _Tp>
 @@ -579,29 +685,150 @@ struct __is_std_optional : false_type {};
 template <class _Tp>
 struct __is_std_optional<optional<_Tp>> : true_type {};
+template <class _Tp, class... _Args>
+inline constexpr bool __is_constructible_for_optional_v = is_constructible_v<_Tp, _Args...>;
+template <class _Tp, class... _Args>
+struct __is_constructible_for_optional : bool_constant<__is_constructible_for_optional_v<_Tp, _Args...>> {};
+template <class _Tp, class _Up, class... _Args>
+inline constexpr bool __is_constructible_for_optional_initializer_list_v =
+    is_constructible_v<_Tp, initializer_list<_Up>&, _Args...>;
+#    if _LIBCPP_STD_VER >= 26
+template <class _Tp, class... _Args>
+inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Args...> = false;
+template <class _Tp, class _Arg>
+inline constexpr bool __is_constructible_for_optional_v<_Tp&, _Arg> =
+    is_constructible_v<_Tp&, _Arg> && !reference_constructs_from_temporary_v<_Tp&, _Arg>;
+template <class _Tp, class _Up, class... _Args>
+inline constexpr bool __is_constructible_for_optional_initializer_list_v<_Tp&, _Up, _Args...> = false;
+#    endif
+template <class _Tp, class = void>
+struct __optional_iterator {};
+#    if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
+template <class _Tp>
+struct __optional_iterator<_Tp, enable_if_t<is_object_v<_Tp>>> {
+private:
+  using __pointer _LIBCPP_NODEBUG       = add_pointer_t<_Tp>;
+  using __const_pointer _LIBCPP_NODEBUG = add_pointer_t<const _Tp>;
+public:
+#      ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+  using iterator       = __bounded_iter<__wrap_iter<__pointer>>;
+  using const_iterator = __bounded_iter<__wrap_iter<__const_pointer>>;
+#      else
+  using iterator       = __wrap_iter<__pointer>;
+  using const_iterator = __wrap_iter<__const_pointer>;
+#      endif
+  // [optional.iterators], iterator support
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() noexcept {
+    auto& __derived_self = static_cast<optional<_Tp>&>(*this);
+    auto* __ptr          = std::addressof(__derived_self.__get());
+#      ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+    return std::__make_bounded_iter(
+        __wrap_iter<__pointer>(__ptr),
+        __wrap_iter<__pointer>(__ptr),
+        __wrap_iter<__pointer>(__ptr) + (__derived_self.has_value() ? 1 : 0));
+#      else
+    return iterator(__ptr);
+#      endif
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator begin() const noexcept {
+    auto& __derived_self = static_cast<const optional<_Tp>&>(*this);
+    auto* __ptr          = std::addressof(__derived_self.__get());
+#      ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+    return std::__make_bounded_iter(
+        __wrap_iter<__const_pointer>(__ptr),
+        __wrap_iter<__const_pointer>(__ptr),
+        __wrap_iter<__const_pointer>(__ptr) + (__derived_self.has_value() ? 1 : 0));
+#      else
+    return const_iterator(__ptr);
+#      endif
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator end() noexcept {
+    return begin() + (static_cast<optional<_Tp>&>(*this).has_value() ? 1 : 0);
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const_iterator end() const noexcept {
+    return begin() + (static_cast<const optional<_Tp>&>(*this).has_value() ? 1 : 0);
+  }
+};
+template <class _Tp>
+struct __optional_iterator<_Tp&, enable_if_t<is_object_v<_Tp> && !__is_unbounded_array_v<_Tp> >> {
+private:
+  using __pointer _LIBCPP_NODEBUG = add_pointer_t<_Tp>;
+public:
+#      ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+  using iterator = __bounded_iter<__wrap_iter<__pointer>>;
+#      else
+  using iterator = __wrap_iter<__pointer>;
+#      endif
+  // [optional.ref.iterators], iterator support
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const noexcept {
+    auto& __derived_self = static_cast<const optional<_Tp&>&>(*this);
+    auto* __ptr          = __derived_self.has_value() ? std::addressof(__derived_self.__get()) : nullptr;
+#      ifdef _LIBCPP_ABI_BOUNDED_ITERATORS_IN_OPTIONAL
+    return std::__make_bounded_iter(
+        __wrap_iter<__pointer>(__ptr),
+        __wrap_iter<__pointer>(__ptr),
+        __wrap_iter<__pointer>(__ptr) + (__derived_self.has_value() ? 1 : 0));
+#      else
+    return iterator(__ptr);
+#      endif
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const noexcept {
+    return begin() + (static_cast<const optional<_Tp&>&>(*this).has_value() ? 1 : 0);
+  }
+};
+#    endif // _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
 template <class _Tp>
 class _LIBCPP_DECLSPEC_EMPTY_BASES optional
     : private __optional_move_assign_base<_Tp>,
       private __optional_sfinae_ctor_base_t<_Tp>,
-      private __optional_sfinae_assign_base_t<_Tp> {
+      private __optional_sfinae_assign_base_t<_Tp>,
+      public __optional_iterator<_Tp> {
   using __base _LIBCPP_NODEBUG = __optional_move_assign_base<_Tp>;
 public:
-  using value_type = _Tp;
+  using value_type = __libcpp_remove_reference_t<_Tp>;
   using __trivially_relocatable _LIBCPP_NODEBUG =
       conditional_t<__libcpp_is_trivially_relocatable<_Tp>::value, optional, void>;
-  using __replaceable _LIBCPP_NODEBUG = conditional_t<__is_replaceable_v<_Tp>, optional, void>;
 private:
-  // Disable the reference extension using this static assert.
+  static_assert(!is_same_v<__remove_cvref_t<_Tp>, in_place_t>,
-  static_assert(!is_same_v<__remove_cvref_t<value_type>, in_place_t>,
                 "instantiation of optional with in_place_t is ill-formed");
-  static_assert(!is_same_v<__remove_cvref_t<value_type>, nullopt_t>,
+  static_assert(!is_same_v<__remove_cvref_t<_Tp>, nullopt_t>, "instantiation of optional with nullopt_t is ill-formed");
-                "instantiation of optional with nullopt_t is ill-formed");
+#    if _LIBCPP_STD_VER >= 26
-  static_assert(!is_reference_v<value_type>, "instantiation of optional with a reference type is ill-formed");
+  static_assert(!is_rvalue_reference_v<_Tp>, "instantiation of optional with an rvalue reference type is ill-formed");
-  static_assert(is_destructible_v<value_type>, "instantiation of optional with a non-destructible type is ill-formed");
+#    else
-  static_assert(!is_array_v<value_type>, "instantiation of optional with an array type is ill-formed");
+  static_assert(!is_reference_v<_Tp>, "instantiation of optional with a reference type is ill-formed");
+#    endif
+  static_assert(is_destructible_v<_Tp>, "instantiation of optional with a non-destructible type is ill-formed");
+  static_assert(!is_array_v<_Tp>, "instantiation of optional with an array type is ill-formed");
+#    if _LIBCPP_STD_VER >= 26
+  template <class _Up>
+  constexpr static bool __libcpp_opt_ref_ctor_deleted =
+      is_lvalue_reference_v<_Tp> && reference_constructs_from_temporary_v<_Tp, _Up>;
+#    endif
   // LWG2756: conditionally explicit conversion from _Up
   struct _CheckOptionalArgsConstructor {
 @@ -674,45 +901,131 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr optional(optional&&)      = default;
   _LIBCPP_HIDE_FROM_ABI constexpr optional(nullopt_t) noexcept {}
-  template <class _InPlaceT,
+  template <
-            class... _Args,
+      class _InPlaceT,
-            enable_if_t<_And<_IsSame<_InPlaceT, in_place_t>, is_constructible<value_type, _Args...>>::value, int> = 0>
+      class... _Args,
+      enable_if_t<_And<_IsSame<_InPlaceT, in_place_t>, __is_constructible_for_optional<_Tp, _Args...>>::value, int> = 0>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_InPlaceT, _Args&&... __args)
       : __base(in_place, std::forward<_Args>(__args)...) {}
   template <class _Up,
             class... _Args,
-            enable_if_t<is_constructible_v<value_type, initializer_list<_Up>&, _Args...>, int> = 0>
+            enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
   _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(in_place_t, initializer_list<_Up> __il, _Args&&... __args)
       : __base(in_place, __il, std::forward<_Args>(__args)...) {}
-  template <class _Up                                                                        = value_type,
+  template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
-            enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v)
-  _LIBCPP_HIDE_FROM_ABI constexpr optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
+#    endif
+      : __base(in_place, std::forward<_Up>(__v)) {
+  }
-  template <class _Up, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
+  template <class _Up                                                                        = remove_cv_t<_Tp>,
-  _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v) : __base(in_place, std::forward<_Up>(__v)) {}
+            enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit optional(_Up&& __v)
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
+#    endif
+      : __base(in_place, std::forward<_Up>(__v)) {
+  }
   // LWG2756: conditionally explicit conversion from const optional<_Up>&
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>& __v)
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up&>)
+#    endif
+  {
     this->__construct_from(__v);
   }
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(const optional<_Up>& __v)
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up&>)
+#    endif
+  {
     this->__construct_from(__v);
   }
   // LWG2756: conditionally explicit conversion from optional<_Up>&&
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(optional<_Up>&& __v)
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
+#    endif
+  {
     this->__construct_from(std::move(__v));
   }
   template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit optional(optional<_Up>&& __v)
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp&, _Up>)
+#    endif
+  {
     this->__construct_from(std::move(__v));
   }
+  // deleted optional<T&> constructors and additional optional<T&> constructors
+#    if _LIBCPP_STD_VER >= 26
+  // optional(U&&)
+  template <class _Up = _Tp, enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_implicit<_Up>(), int> = 0>
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
+  optional(_Up&&) = delete;
+  template <class _Up                                                                        = remove_cv_t<_Tp>,
+            enable_if_t<_CheckOptionalArgsCtor<_Up>::template __enable_explicit<_Up>(), int> = 0>
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
+  explicit optional(_Up&&) = delete;
+  // optional(optional<U>& rhs)
+  template <class _Up>
+    requires(!__libcpp_opt_ref_ctor_deleted<_Up>) && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
+            (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, _Up&>
+  _LIBCPP_HIDE_FROM_ABI constexpr explicit(!is_convertible_v<_Up&, _Tp&>)
+      optional(optional<_Up>& __rhs) noexcept(is_nothrow_constructible_v<_Tp&, _Up&>) {
+    this->__construct_from(__rhs);
+  }
+  template <class _Up>
+    requires __libcpp_opt_ref_ctor_deleted<_Up> && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
+                 (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, _Up&>
+  constexpr explicit optional(optional<_Up>& __rhs) noexcept = delete;
+  // optional(const optional<U>&)
+  template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_implicit<_Up>(), int> = 0>
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
+  optional(const optional<_Up>&) = delete;
+  template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up const&>::template __enable_explicit<_Up>(), int> = 0>
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
+  explicit optional(const optional<_Up>&) = delete;
+  // optional(optional<U>&&)
+  template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_implicit<_Up>(), int> = 0>
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
+  optional(optional<_Up>&&) = delete;
+  template <class _Up, enable_if_t<_CheckOptionalLikeCtor<_Up, _Up&&>::template __enable_explicit<_Up>(), int> = 0>
+    requires __libcpp_opt_ref_ctor_deleted<_Up>
+  explicit optional(optional<_Up>&&) = delete;
+  // optional(const optional<U>&&)
+  template <class _Up>
+    requires(!__libcpp_opt_ref_ctor_deleted<_Up>) && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
+            (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(!is_convertible_v<const _Up, _Tp&>)
+      optional(const optional<_Up>&& __v) noexcept(is_nothrow_constructible_v<_Tp&, const _Up>) {
+    this->__construct_from(std::move(__v));
+  }
+  template <class _Up>
+    requires __libcpp_opt_ref_ctor_deleted<_Up> && (!is_same_v<remove_cvref_t<_Tp>, optional<_Up>>) &&
+                 (!is_same_v<_Tp&, _Up>) && is_constructible_v<_Tp&, _Up>
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional(const optional<_Up>&& __v) noexcept = delete;
+#    endif
 #    if _LIBCPP_STD_VER >= 23
   template <class _Tag,
             class _Fp,
 @@ -731,11 +1044,12 @@ public:
   _LIBCPP_HIDE_FROM_ABI constexpr optional& operator=(optional&&)      = default;
   // LWG2756
-  template <class _Up        = value_type,
+  template <class _Up        = remove_cv_t<_Tp>,
             enable_if_t<_And<_IsNotSame<__remove_cvref_t<_Up>, optional>,
-                             _Or<_IsNotSame<__remove_cvref_t<_Up>, value_type>, _Not<is_scalar<value_type>>>,
+                             _Or<_IsNotSame<__remove_cvref_t<_Up>, _Tp>, _Not<is_scalar<_Tp>>>,
-                             is_constructible<value_type, _Up>,
+                             is_constructible<_Tp, _Up>,
-                             is_assignable<value_type&, _Up>>::value,
+                             is_assignable<_Tp&, _Up>,
+                             is_object<_Tp>>::value,
                         int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 optional& operator=(_Up&& __v) {
     if (this->has_value())
 @@ -759,8 +1073,12 @@ public:
     return *this;
   }
-  template <class... _Args, enable_if_t<is_constructible_v<value_type, _Args...>, int> = 0>
+  template <class... _Args, enable_if_t<__is_constructible_for_optional_v<_Tp, _Args...>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args) {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(_Args&&... __args)
+#    if _LIBCPP_STD_VER >= 26
+      noexcept(is_lvalue_reference_v<_Tp> && is_nothrow_constructible_v<_Tp, _Args...>)
+#    endif
+  {
     reset();
     this->__construct(std::forward<_Args>(__args)...);
     return this->__get();
 @@ -768,56 +1086,72 @@ public:
   template <class _Up,
             class... _Args,
-            enable_if_t<is_constructible_v<value_type, initializer_list<_Up>&, _Args...>, int> = 0>
+            enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _Tp& emplace(initializer_list<_Up> __il, _Args&&... __args) {
     reset();
     this->__construct(__il, std::forward<_Args>(__args)...);
     return this->__get();
   }
-  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(optional& __opt) noexcept(
-  swap(optional& __opt) noexcept(is_nothrow_move_constructible_v<value_type> && is_nothrow_swappable_v<value_type>) {
+      (is_nothrow_move_constructible_v<_Tp> && is_nothrow_swappable_v<_Tp>)
-    if (this->has_value() == __opt.has_value()) {
+#    if _LIBCPP_STD_VER >= 26
-      using std::swap;
+      || is_lvalue_reference_v<_Tp>
-      if (this->has_value())
+#    endif
-        swap(this->__get(), __opt.__get());
+  ) {
-    } else {
+    this->__swap(__opt);
-      if (this->has_value()) {
-        __opt.__construct(std::move(this->__get()));
-        reset();
-      } else {
-        this->__construct(std::move(__opt.__get()));
-        __opt.reset();
-      }
-    }
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<value_type const> operator->() const noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp const> operator->() const noexcept
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
     return std::addressof(this->__get());
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<value_type> operator->() noexcept {
+  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() noexcept
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
     return std::addressof(this->__get());
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr const value_type& operator*() const& noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& operator*() const& noexcept
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
     return this->__get();
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type& operator*() & noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() & noexcept
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
     return this->__get();
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& operator*() && noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& operator*() && noexcept
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
     return std::move(this->__get());
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr const value_type&& operator*() const&& noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& operator*() const&& noexcept
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
     return std::move(this->__get());
   }
 @@ -827,48 +1161,73 @@ public:
   using __base::__get;
   using __base::has_value;
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type const& value() const& {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp const& value() const&
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     if (!this->has_value())
       std::__throw_bad_optional_access();
     return this->__get();
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type& value() & {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() &
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     if (!this->has_value())
       std::__throw_bad_optional_access();
     return this->__get();
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type&& value() && {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& value() &&
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     if (!this->has_value())
       std::__throw_bad_optional_access();
     return std::move(this->__get());
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type const&& value() const&& {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp const&& value() const&&
+#    if _LIBCPP_STD_VER >= 26
+    requires(is_object_v<_Tp>)
+#    endif
+  {
     if (!this->has_value())
       std::__throw_bad_optional_access();
     return std::move(this->__get());
   }
-  template <class _Up>
+  template <class _Up = remove_cv_t<_Tp>>
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type value_or(_Up&& __v) const& {
+#    if _LIBCPP_STD_VER >= 26
-    static_assert(is_copy_constructible_v<value_type>, "optional<T>::value_or: T must be copy constructible");
+    requires(is_object_v<_Tp>)
-    static_assert(is_convertible_v<_Up, value_type>, "optional<T>::value_or: U must be convertible to T");
+#    endif
-    return this->has_value() ? this->__get() : static_cast<value_type>(std::forward<_Up>(__v));
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) const& {
+    static_assert(is_copy_constructible_v<_Tp>, "optional<T>::value_or: T must be copy constructible");
+    static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
+    return this->has_value() ? this->__get() : static_cast<_Tp>(std::forward<_Up>(__v));
   }
-  template <class _Up>
+  template <class _Up = remove_cv_t<_Tp>>
-  _LIBCPP_HIDE_FROM_ABI constexpr value_type value_or(_Up&& __v) && {
+#    if _LIBCPP_STD_VER >= 26
-    static_assert(is_move_constructible_v<value_type>, "optional<T>::value_or: T must be move constructible");
+    requires(is_object_v<_Tp>)
-    static_assert(is_convertible_v<_Up, value_type>, "optional<T>::value_or: U must be convertible to T");
+#    endif
-    return this->has_value() ? std::move(this->__get()) : static_cast<value_type>(std::forward<_Up>(__v));
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp value_or(_Up&& __v) && {
+    static_assert(is_move_constructible_v<_Tp>, "optional<T>::value_or: T must be move constructible");
+    static_assert(is_convertible_v<_Up, _Tp>, "optional<T>::value_or: U must be convertible to T");
+    return this->has_value() ? std::move(this->__get()) : static_cast<_Tp>(std::forward<_Up>(__v));
   }
 #    if _LIBCPP_STD_VER >= 23
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = invoke_result_t<_Func, value_type&>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) & {
+    using _Up = invoke_result_t<_Func, _Tp&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(value()) must be a specialization of std::optional");
     if (*this)
 @@ -877,8 +1236,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = invoke_result_t<_Func, const value_type&>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const& {
+    using _Up = invoke_result_t<_Func, const _Tp&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(value()) must be a specialization of std::optional");
     if (*this)
 @@ -887,8 +1249,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = invoke_result_t<_Func, value_type&&>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) && {
+    using _Up = invoke_result_t<_Func, _Tp&&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (*this)
 @@ -897,8 +1262,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = invoke_result_t<_Func, const value_type&&>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const&& {
+    using _Up = invoke_result_t<_Func, const _Tp&&>;
     static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
                   "Result of f(std::move(value())) must be a specialization of std::optional");
     if (*this)
 @@ -907,8 +1275,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = remove_cv_t<invoke_result_t<_Func, value_type&>>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) & {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&>>;
     static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
 @@ -919,8 +1290,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = remove_cv_t<invoke_result_t<_Func, const value_type&>>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&>>;
     static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
 @@ -931,8 +1305,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = remove_cv_t<invoke_result_t<_Func, value_type&&>>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) && {
+    using _Up = remove_cv_t<invoke_result_t<_Func, _Tp&&>>;
     static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
 @@ -943,8 +1320,11 @@ public:
   }
   template <class _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+#      if _LIBCPP_STD_VER >= 26
-    using _Up = remove_cvref_t<invoke_result_t<_Func, const value_type&&>>;
+    requires(is_object_v<_Tp>)
+#      endif
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto transform(_Func&& __f) const&& {
+    using _Up = remove_cv_t<invoke_result_t<_Func, const _Tp&&>>;
     static_assert(!is_array_v<_Up>, "Result of f(std::move(value())) should not be an Array");
     static_assert(!is_same_v<_Up, in_place_t>, "Result of f(std::move(value())) should not be std::in_place_t");
     static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(std::move(value())) should not be std::nullopt_t");
 @@ -955,8 +1335,11 @@ public:
   }
   template <invocable _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const&
-    requires is_copy_constructible_v<value_type>
+    requires is_copy_constructible_v<_Tp>
+#      if _LIBCPP_STD_VER >= 26
+             && (is_object_v<_Tp>)
+#      endif
   {
     static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
                   "Result of f() should be the same type as this optional");
 @@ -966,8 +1349,11 @@ public:
   }
   template <invocable _Func>
-  _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) &&
-    requires is_move_constructible_v<value_type>
+    requires is_move_constructible_v<_Tp>
+#      if _LIBCPP_STD_VER >= 26
+             && (is_object_v<_Tp>)
+#      endif
   {
     static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
                   "Result of f() should be the same type as this optional");
 @@ -978,6 +1364,78 @@ public:
 #    endif // _LIBCPP_STD_VER >= 23
   using __base::reset;
+// optional<T&> overloads
+#    if _LIBCPP_STD_VER >= 26
+  _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> operator->() const noexcept
+    requires(is_lvalue_reference_v<_Tp>)
+  {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator-> called on a disengaged value");
+    return std::addressof(this->__get());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& operator*() const noexcept
+    requires(is_lvalue_reference_v<_Tp>)
+  {
+    _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(this->has_value(), "optional operator* called on a disengaged value");
+    return this->__get();
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& value() const
+    requires(is_lvalue_reference_v<_Tp>)
+  {
+    if (!this->has_value())
+      std::__throw_bad_optional_access();
+    return this->__get();
+  }
+  template <class _Up = remove_cvref_t<_Tp>>
+    requires(is_lvalue_reference_v<_Tp> && is_object_v<__libcpp_remove_reference_t<_Tp>> &&
+             !is_array_v<__libcpp_remove_reference_t<_Tp>>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decay_t<_Tp> value_or(_Up&& __v) const {
+    static_assert(
+        is_constructible_v<remove_cvref_t<_Tp>, _Tp&>, "optional<T&>::value_or: remove_cv_t<T> must be constructible");
+    static_assert(
+        is_convertible_v<_Up, remove_cvref_t<_Tp>>, "optional<T&>::value_or: U must be convertible to remove_cv_t<T>");
+    return this->has_value() ? this->__get() : static_cast<remove_cvref_t<_Tp>>(std::forward<_Up>(__v));
+  }
+  template <class _Func>
+    requires(is_lvalue_reference_v<_Tp>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto and_then(_Func&& __f) const {
+    using _Up = invoke_result_t<_Func, _Tp&>;
+    static_assert(__is_std_optional<remove_cvref_t<_Up>>::value,
+                  "Result of f(value()) must be a specialization of std::optional");
+    if (*this)
+      return std::invoke(std::forward<_Func>(__f), value());
+    return remove_cvref_t<_Up>();
+  }
+  template <class _Func>
+    requires(is_lvalue_reference_v<_Tp>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional<remove_cv_t<invoke_result_t<_Func, _Tp&>>>
+  transform(_Func&& __f) const {
+    using _Up = remove_cvref_t<invoke_result_t<_Func, _Tp&>>;
+    static_assert(!is_array_v<_Up>, "Result of f(value()) should not be an Array");
+    static_assert(!is_same_v<_Up, in_place_t>, "Result of f(value()) should not be std::in_place_t");
+    static_assert(!is_same_v<_Up, nullopt_t>, "Result of f(value()) should not be std::nullopt_t");
+    static_assert(is_object_v<_Up>, "Result of f(value()) should be an object type");
+    if (*this)
+      return optional<_Up>(__optional_construct_from_invoke_tag{}, std::forward<_Func>(__f), value());
+    return optional<_Up>();
+  }
+  template <invocable _Func>
+    requires(is_lvalue_reference_v<_Tp>)
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional or_else(_Func&& __f) const {
+    static_assert(is_same_v<remove_cvref_t<invoke_result_t<_Func>>, optional>,
+                  "Result of f() should be the same type as this optional");
+    if (*this)
+      return *this;
+    return std::forward<_Func>(__f)();
+  }
+#    endif
 };
 template <class _Tp>
 @@ -1154,7 +1612,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const optional<_Tp>& __x, const _Up& __v) {
-  return static_cast<bool>(__x) ? *__x == __v : false;
+  if (__x.has_value())
+    return *__x == __v;
+  return false;
 }
 template <
 @@ -1163,7 +1623,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() == std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator==(const _Tp& __v, const optional<_Up>& __x) {
-  return static_cast<bool>(__x) ? __v == *__x : false;
+  if (__x.has_value())
+    return __v == *__x;
+  return false;
 }
 template <
 @@ -1172,7 +1634,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const optional<_Tp>& __x, const _Up& __v) {
-  return static_cast<bool>(__x) ? *__x != __v : true;
+  if (__x.has_value())
+    return *__x != __v;
+  return true;
 }
 template <
 @@ -1181,7 +1645,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() != std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator!=(const _Tp& __v, const optional<_Up>& __x) {
-  return static_cast<bool>(__x) ? __v != *__x : true;
+  if (__x.has_value())
+    return __v != *__x;
+  return true;
 }
 template < class _Tp,
 @@ -1189,7 +1655,9 @@ template < class _Tp,
            enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
                        int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const optional<_Tp>& __x, const _Up& __v) {
-  return static_cast<bool>(__x) ? *__x < __v : true;
+  if (__x.has_value())
+    return *__x < __v;
+  return true;
 }
 template < class _Tp,
 @@ -1197,7 +1665,9 @@ template < class _Tp,
            enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() < std::declval<const _Up&>()), bool>,
                        int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<(const _Tp& __v, const optional<_Up>& __x) {
-  return static_cast<bool>(__x) ? __v < *__x : false;
+  if (__x.has_value())
+    return __v < *__x;
+  return false;
 }
 template <
 @@ -1206,7 +1676,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const optional<_Tp>& __x, const _Up& __v) {
-  return static_cast<bool>(__x) ? *__x <= __v : true;
+  if (__x.has_value())
+    return *__x <= __v;
+  return true;
 }
 template <
 @@ -1215,7 +1687,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() <= std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator<=(const _Tp& __v, const optional<_Up>& __x) {
-  return static_cast<bool>(__x) ? __v <= *__x : false;
+  if (__x.has_value())
+    return __v <= *__x;
+  return false;
 }
 template < class _Tp,
 @@ -1223,7 +1697,9 @@ template < class _Tp,
            enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
                        int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const optional<_Tp>& __x, const _Up& __v) {
-  return static_cast<bool>(__x) ? *__x > __v : false;
+  if (__x.has_value())
+    return *__x > __v;
+  return false;
 }
 template < class _Tp,
 @@ -1231,7 +1707,9 @@ template < class _Tp,
            enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() > std::declval<const _Up&>()), bool>,
                        int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>(const _Tp& __v, const optional<_Up>& __x) {
-  return static_cast<bool>(__x) ? __v > *__x : true;
+  if (__x.has_value())
+    return __v > *__x;
+  return true;
 }
 template <
 @@ -1240,7 +1718,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const optional<_Tp>& __x, const _Up& __v) {
-  return static_cast<bool>(__x) ? *__x >= __v : false;
+  if (__x.has_value())
+    return *__x >= __v;
+  return false;
 }
 template <
 @@ -1249,7 +1729,9 @@ template <
     enable_if_t<__is_core_convertible_v<decltype(std::declval<const _Tp&>() >= std::declval<const _Up&>()), bool>,
                 int> = 0>
 _LIBCPP_HIDE_FROM_ABI constexpr bool operator>=(const _Tp& __v, const optional<_Up>& __x) {
-  return static_cast<bool>(__x) ? __v >= *__x : true;
+  if (__x.has_value())
+    return __v >= *__x;
+  return true;
 }
 #    if _LIBCPP_STD_VER >= 20
 @@ -1264,23 +1746,36 @@ operator<=>(const optional<_Tp>& __x, const _Up& __v) {
 #    endif // _LIBCPP_STD_VER >= 20
 template <class _Tp, enable_if_t< is_move_constructible_v<_Tp> && is_swappable_v<_Tp>, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
+inline _LIBCPP_HIDE_FROM_ABI
-swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) {
+_LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(optional<_Tp>& __x, optional<_Tp>& __y) noexcept(noexcept(__x.swap(__y))) {
   __x.swap(__y);
 }
-template <class _Tp>
+struct __make_optional_barrier_tag {
-_LIBCPP_HIDE_FROM_ABI constexpr optional<decay_t<_Tp>> make_optional(_Tp&& __v) {
+  explicit __make_optional_barrier_tag() = default;
+};
+template <
+#    if _LIBCPP_STD_VER >= 26
+    __make_optional_barrier_tag = __make_optional_barrier_tag{},
+#    endif
+    class _Tp,
+    enable_if_t<is_constructible_v<decay_t<_Tp>, _Tp>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional<decay_t<_Tp>> make_optional(_Tp&& __v) {
   return optional<decay_t<_Tp>>(std::forward<_Tp>(__v));
 }
-template <class _Tp, class... _Args>
+template <class _Tp, class... _Args, enable_if_t<__is_constructible_for_optional_v<_Tp, _Args...>, int> = 0>
-_LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(_Args&&... __args) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(_Args&&... __args) {
   return optional<_Tp>(in_place, std::forward<_Args>(__args)...);
 }
-template <class _Tp, class _Up, class... _Args>
+template <class _Tp,
-_LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp> make_optional(initializer_list<_Up> __il, _Args&&... __args) {
+          class _Up,
+          class... _Args,
+          enable_if_t<__is_constructible_for_optional_initializer_list_v<_Tp, _Up, _Args...>, int> = 0>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr optional<_Tp>
+make_optional(initializer_list<_Up> __il, _Args&&... __args) {
   return optional<_Tp>(in_place, __il, std::forward<_Args>(__args)...);
 }
 @@ -1291,7 +1786,7 @@ struct hash< __enable_hash_helper<optional<_Tp>, remove_const_t<_Tp>> > {
   _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
 #    endif
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const optional<_Tp>& __opt) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const optional<_Tp>& __opt) const {
     return static_cast<bool>(__opt) ? hash<remove_const_t<_Tp>>()(*__opt) : 0;
   }
 };

lib/libcxx/include/print+9-5

...	@@ -329,7 +329,8 @@ __vprint_unicode([[maybe_unused]] FILE* __stream,	...	@@ -329,7 +329,8 @@ __vprint_unicode([[maybe_unused]] FILE* __stream,
329	} // namespace __print	329	} // namespace __print
330		330
331	template <class... _Args>	331	template <class... _Args>
332	_LIBCPP_HIDE_FROM_ABI void print(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {	332	_LIBCPP_HIDE_FROM_ABI void
		333	print(FILE* _LIBCPP_DIAGNOSE_NULLPTR __stream, format_string<_Args...> __fmt, _Args&&... __args) {
333	# if _LIBCPP_HAS_UNICODE	334	# if _LIBCPP_HAS_UNICODE
334	if constexpr (__print::__use_unicode_execution_charset)	335	if constexpr (__print::__use_unicode_execution_charset)
335	__print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), false);	336	__print::__vprint_unicode(__stream, __fmt.get(), std::make_format_args(__args...), false);
...	@@ -346,7 +347,8 @@ _LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __arg	...	@@ -346,7 +347,8 @@ _LIBCPP_HIDE_FROM_ABI void print(format_string<_Args...> __fmt, _Args&&... __arg
346	}	347	}
347		348
348	template <class... _Args>	349	template <class... _Args>
349	_LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt, _Args&&... __args) {	350	_LIBCPP_HIDE_FROM_ABI void
		351	println(FILE* _LIBCPP_DIAGNOSE_NULLPTR __stream, format_string<_Args...> __fmt, _Args&&... __args) {
350	# if _LIBCPP_HAS_UNICODE	352	# if _LIBCPP_HAS_UNICODE
351	// Note the wording in the Standard is inefficient. The output of	353	// Note the wording in the Standard is inefficient. The output of
352	// std::format is a std::string which is then copied. This solution	354	// std::format is a std::string which is then copied. This solution
...	@@ -361,7 +363,7 @@ _LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt	...	@@ -361,7 +363,7 @@ _LIBCPP_HIDE_FROM_ABI void println(FILE* __stream, format_string<_Args...> __fmt
361	}	363	}
362		364
363	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).	365	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
364	_LIBCPP_HIDE_FROM_ABI inline void println(FILE* __stream) {	366	_LIBCPP_HIDE_FROM_ABI inline void println(FILE* _LIBCPP_DIAGNOSE_NULLPTR __stream) {
365	std::print(__stream, "\n");	367	std::print(__stream, "\n");
366	}	368	}
367		369
...	@@ -377,7 +379,8 @@ _LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __a	...	@@ -377,7 +379,8 @@ _LIBCPP_HIDE_FROM_ABI void println(format_string<_Args...> __fmt, _Args&&... __a
377		379
378	# if _LIBCPP_HAS_UNICODE	380	# if _LIBCPP_HAS_UNICODE
379	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).	381	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
380	_LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(FILE* __stream, string_view __fmt, format_args __args) {	382	_LIBCPP_HIDE_FROM_ABI inline void
		383	vprint_unicode(FILE* _LIBCPP_DIAGNOSE_NULLPTR __stream, string_view __fmt, format_args __args) {
381	__print::__vprint_unicode(__stream, __fmt, __args, false);	384	__print::__vprint_unicode(__stream, __fmt, __args, false);
382	}	385	}
383		386
...	@@ -389,7 +392,8 @@ _LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(string_view __fmt, format_args	...	@@ -389,7 +392,8 @@ _LIBCPP_HIDE_FROM_ABI inline void vprint_unicode(string_view __fmt, format_args
389	# endif // _LIBCPP_HAS_UNICODE	392	# endif // _LIBCPP_HAS_UNICODE
390		393
391	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).	394	template <class = void> // TODO PRINT template or availability markup fires too eagerly (http://llvm.org/PR61563).
392	_LIBCPP_HIDE_FROM_ABI inline void vprint_nonunicode(FILE* __stream, string_view __fmt, format_args __args) {	395	_LIBCPP_HIDE_FROM_ABI inline void
		396	vprint_nonunicode(FILE* _LIBCPP_DIAGNOSE_NULLPTR __stream, string_view __fmt, format_args __args) {
393	__print::__vprint_nonunicode(__stream, __fmt, __args, false);	397	__print::__vprint_nonunicode(__stream, __fmt, __args, false);
394	}	398	}
395		399

lib/libcxx/include/queue+39-37

 @@ -376,12 +376,12 @@ public:
 #  endif // _LIBCPP_CXX03_LANG
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
-  _LIBCPP_HIDE_FROM_ABI reference front() { return c.front(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference front() { return c.front(); }
-  _LIBCPP_HIDE_FROM_ABI const_reference front() const { return c.front(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference front() const { return c.front(); }
-  _LIBCPP_HIDE_FROM_ABI reference back() { return c.back(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference back() { return c.back(); }
-  _LIBCPP_HIDE_FROM_ABI const_reference back() const { return c.back(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference back() const { return c.back(); }
   _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); }
 #  ifndef _LIBCPP_CXX03_LANG
 @@ -437,19 +437,19 @@ public:
 };
 #  if _LIBCPP_STD_VER >= 17
-template <class _Container, class = enable_if_t<!__is_allocator<_Container>::value> >
+template <class _Container, class = enable_if_t<!__is_allocator_v<_Container>>>
 queue(_Container) -> queue<typename _Container::value_type, _Container>;
 template <class _Container,
           class _Alloc,
-          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<!__is_allocator_v<_Container>>,
           class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
 queue(_Container, _Alloc) -> queue<typename _Container::value_type, _Container>;
 #  endif
 #  if _LIBCPP_STD_VER >= 23
 template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
-queue(_InputIterator, _InputIterator) -> queue<__iter_value_type<_InputIterator>>;
+queue(_InputIterator, _InputIterator) -> queue<__iterator_value_type<_InputIterator>>;
 template <ranges::input_range _Range>
 queue(from_range_t, _Range&&) -> queue<ranges::range_value_t<_Range>>;
 @@ -457,11 +457,11 @@ queue(from_range_t, _Range&&) -> queue<ranges::range_value_t<_Range>>;
 template <class _InputIterator,
           class _Alloc,
           __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
-          __enable_if_t<__is_allocator<_Alloc>::value, int>                        = 0>
+          __enable_if_t<__is_allocator_v<_Alloc>, int>                             = 0>
 queue(_InputIterator, _InputIterator, _Alloc)
-    -> queue<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;
+    -> queue<__iterator_value_type<_InputIterator>, deque<__iterator_value_type<_InputIterator>, _Alloc>>;
-template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator<_Alloc>::value, int> = 0>
+template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator_v<_Alloc>, int> = 0>
 queue(from_range_t, _Range&&, _Alloc)
     -> queue<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
 #  endif
 @@ -664,8 +664,10 @@ public:
 #  endif
   [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
-  _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.front(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI const_reference top() const {
+    return c.front();
+  }
   _LIBCPP_CONSTEXPR_SINCE_CXX26 _LIBCPP_HIDE_FROM_ABI void push(const value_type& __v);
 #  ifndef _LIBCPP_CXX03_LANG
 @@ -700,45 +702,45 @@ public:
 #  if _LIBCPP_STD_VER >= 17
 template <class _Compare,
           class _Container,
-          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator_v<_Compare>>,
-          class = enable_if_t<!__is_allocator<_Container>::value> >
+          class = enable_if_t<!__is_allocator_v<_Container>>>
 priority_queue(_Compare, _Container) -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 template <class _InputIterator,
-          class _Compare   = less<__iter_value_type<_InputIterator>>,
+          class _Compare   = less<__iterator_value_type<_InputIterator>>,
-          class _Container = vector<__iter_value_type<_InputIterator>>,
+          class _Container = vector<__iterator_value_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Compare>>,
-          class            = enable_if_t<!__is_allocator<_Container>::value> >
+          class            = enable_if_t<!__is_allocator_v<_Container>>>
 priority_queue(_InputIterator, _InputIterator, _Compare = _Compare(), _Container = _Container())
-    -> priority_queue<__iter_value_type<_InputIterator>, _Container, _Compare>;
+    -> priority_queue<__iterator_value_type<_InputIterator>, _Container, _Compare>;
 template <class _Compare,
           class _Container,
           class _Alloc,
-          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator_v<_Compare>>,
-          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<!__is_allocator_v<_Container>>,
-          class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
+          class = enable_if_t<uses_allocator<_Container, _Alloc>::value>>
 priority_queue(_Compare, _Container, _Alloc) -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value> >
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 priority_queue(_InputIterator, _InputIterator, _Allocator)
-    -> priority_queue<__iter_value_type<_InputIterator>,
+    -> priority_queue<__iterator_value_type<_InputIterator>,
-                      vector<__iter_value_type<_InputIterator>, _Allocator>,
+                      vector<__iterator_value_type<_InputIterator>, _Allocator>,
-                      less<__iter_value_type<_InputIterator>>>;
+                      less<__iterator_value_type<_InputIterator>>>;
 template <class _InputIterator,
           class _Compare,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator_v<_Compare>>,
-          class = enable_if_t<__is_allocator<_Allocator>::value> >
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 priority_queue(_InputIterator, _InputIterator, _Compare, _Allocator)
-    -> priority_queue<__iter_value_type<_InputIterator>,
+    -> priority_queue<__iterator_value_type<_InputIterator>,
-                      vector<__iter_value_type<_InputIterator>, _Allocator>,
+                      vector<__iterator_value_type<_InputIterator>, _Allocator>,
                       _Compare>;
 template <class _InputIterator,
 @@ -746,8 +748,8 @@ template <class _InputIterator,
           class _Container,
           class _Alloc,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator_v<_Compare>>,
-          class = enable_if_t<!__is_allocator<_Container>::value>,
+          class = enable_if_t<!__is_allocator_v<_Container>>,
           class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
 priority_queue(_InputIterator, _InputIterator, _Compare, _Container, _Alloc)
     -> priority_queue<typename _Container::value_type, _Container, _Compare>;
 @@ -757,19 +759,19 @@ priority_queue(_InputIterator, _InputIterator, _Compare, _Container, _Alloc)
 template <ranges::input_range _Range,
           class _Compare = less<ranges::range_value_t<_Range>>,
-          class          = enable_if_t<!__is_allocator<_Compare>::value>>
+          class          = enable_if_t<!__is_allocator_v<_Compare>>>
 priority_queue(from_range_t, _Range&&, _Compare = _Compare())
     -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>>, _Compare>;
 template <ranges::input_range _Range,
           class _Compare,
           class _Alloc,
-          class = enable_if_t<!__is_allocator<_Compare>::value>,
+          class = enable_if_t<!__is_allocator_v<_Compare>>,
-          class = enable_if_t<__is_allocator<_Alloc>::value>>
+          class = enable_if_t<__is_allocator_v<_Alloc>>>
 priority_queue(from_range_t, _Range&&, _Compare, _Alloc)
     -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>, _Compare>;
-template <ranges::input_range _Range, class _Alloc, class = enable_if_t<__is_allocator<_Alloc>::value>>
+template <ranges::input_range _Range, class _Alloc, class = enable_if_t<__is_allocator_v<_Alloc>>>
 priority_queue(from_range_t, _Range&&, _Alloc)
     -> priority_queue<ranges::range_value_t<_Range>, vector<ranges::range_value_t<_Range>, _Alloc>>;

lib/libcxx/include/ranges+48

...	@@ -116,6 +116,10 @@ namespace std::ranges {	...	@@ -116,6 +116,10 @@ namespace std::ranges {
116	// [range.dangling], dangling iterator handling	116	// [range.dangling], dangling iterator handling
117	struct dangling;	117	struct dangling;
118		118
		119	// [range.elementsof], class template elements_of
		120	template<range R, class Allocator = allocator<byte>>
		121	struct elements_of;
		122
119	template<range R>	123	template<range R>
120	using borrowed_iterator_t = see below;	124	using borrowed_iterator_t = see below;
121		125
...	@@ -267,6 +271,11 @@ namespace std::ranges {	...	@@ -267,6 +271,11 @@ namespace std::ranges {
267	template<class W, class Bound>	271	template<class W, class Bound>
268	inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;	272	inline constexpr bool enable_borrowed_range<iota_view<W, Bound>> = true;
269		273
		274	namespace views {
		275	inline constexpr unspecified iota = unspecified;
		276	inline constexpr unspecified indices = unspecified; // Since C++26
		277	}
		278
270	// [range.repeat], repeat view	279	// [range.repeat], repeat view
271	template<class T>	280	template<class T>
272	concept integer-like-with-usable-difference-type = // exposition only	281	concept integer-like-with-usable-difference-type = // exposition only
...	@@ -339,6 +348,41 @@ namespace std::ranges {	...	@@ -339,6 +348,41 @@ namespace std::ranges {
339		348
340	namespace views { inline constexpr unspecified zip = unspecified; } // C++23	349	namespace views { inline constexpr unspecified zip = unspecified; } // C++23
341		350
		351	// [range.zip.transform], zip transform view
		352	template<move_constructible F, input_range... Views>
		353	requires (view<Views> && ...) && (sizeof...(Views) > 0) && is_object_v<F> &&
		354	regular_invocable<F&, range_reference_t<Views>...> &&
		355	can-reference<invoke_result_t<F&, range_reference_t<Views>...>>
		356	class zip_transform_view; // C++23
		357
		358	namespace views { inline constexpr unspecified zip_transform = unspecified; } // C++23
		359
		360	// [range.adjacent], adjacent view
		361	template<forward_range V, size_t N>
		362	requires view<V> && (N > 0)
		363	class adjacent_view;
		364
		365	template<class V, size_t N>
		366	constexpr bool enable_borrowed_range<adjacent_view<V, N>> =
		367	enable_borrowed_range<V>;
		368
		369	namespace views {
		370	template<size_t N>
		371	constexpr unspecified adjacent = unspecified;
		372	inline constexpr auto pairwise = adjacent<2>;
		373	}
		374
		375	// [range.adjacent.transform], adjacent transform view
		376	template<forward_range V, move_constructible F, size_t N>
		377	requires see below
		378	class adjacent_transform_view;
		379
		380	namespace views {
		381	template<size_t N>
		382	constexpr unspecified adjacent_transform = unspecified;
		383	inline constexpr auto pairwise_transform = adjacent_transform<2>;
		384	}
		385
342	// [range.as.rvalue]	386	// [range.as.rvalue]
343	template <view V>	387	template <view V>
344	requires input_range<V>	388	requires input_range<V>
...	@@ -404,6 +448,7 @@ namespace std {	...	@@ -404,6 +448,7 @@ namespace std {
404	# include <__ranges/data.h>	448	# include <__ranges/data.h>
405	# include <__ranges/drop_view.h>	449	# include <__ranges/drop_view.h>
406	# include <__ranges/drop_while_view.h>	450	# include <__ranges/drop_while_view.h>
		451	# include <__ranges/elements_of.h>
407	# include <__ranges/elements_view.h>	452	# include <__ranges/elements_view.h>
408	# include <__ranges/empty.h>	453	# include <__ranges/empty.h>
409	# include <__ranges/empty_view.h>	454	# include <__ranges/empty_view.h>
...	@@ -433,12 +478,15 @@ namespace std {	...	@@ -433,12 +478,15 @@ namespace std {
433	# endif	478	# endif
434		479
435	# if _LIBCPP_STD_VER >= 23	480	# if _LIBCPP_STD_VER >= 23
		481	# include <__ranges/adjacent_transform_view.h>
		482	# include <__ranges/adjacent_view.h>
436	# include <__ranges/as_rvalue_view.h>	483	# include <__ranges/as_rvalue_view.h>
437	# include <__ranges/chunk_by_view.h>	484	# include <__ranges/chunk_by_view.h>
438	# include <__ranges/from_range.h>	485	# include <__ranges/from_range.h>
439	# include <__ranges/join_with_view.h>	486	# include <__ranges/join_with_view.h>
440	# include <__ranges/repeat_view.h>	487	# include <__ranges/repeat_view.h>
441	# include <__ranges/to.h>	488	# include <__ranges/to.h>
		489	# include <__ranges/zip_transform_view.h>
442	# include <__ranges/zip_view.h>	490	# include <__ranges/zip_view.h>
443	# endif	491	# endif
444		492

lib/libcxx/include/regex+33-31

 @@ -986,7 +986,7 @@ public:
   explicit regex_error(regex_constants::error_type __ecode);
   _LIBCPP_HIDE_FROM_ABI regex_error(const regex_error&) _NOEXCEPT = default;
   ~regex_error() _NOEXCEPT override;
-  _LIBCPP_HIDE_FROM_ABI regex_constants::error_type code() const { return __code_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI regex_constants::error_type code() const { return __code_; }
 };
 template <regex_constants::error_type _Ev>
 @@ -1004,7 +1004,7 @@ public:
   typedef _CharT char_type;
   typedef basic_string<char_type> string_type;
   typedef locale locale_type;
-#    if defined(__BIONIC__) || defined(_NEWLIB_VERSION)
+#    if defined(__BIONIC__) || _LIBCPP_LIBC_NEWLIB
   // Originally bionic's ctype_base used its own ctype masks because the
   // builtin ctype implementation wasn't in libc++ yet. Bionic's ctype mask
   // was only 8 bits wide and already saturated, so it used a wider type here
 @@ -1013,9 +1013,7 @@ public:
   // implementation, but this was not updated to match. Since then Android has
   // needed to maintain a stable libc++ ABI, and this can't be changed without
   // an ABI break.
-  // We also need this workaround for newlib since _NEWLIB_VERSION is not
+  // We also need this workaround for newlib since newlib is
-  // defined yet inside __config, so we can't set the
-  // _LIBCPP_PROVIDES_DEFAULT_RUNE_TABLE macro. Additionally, newlib is
   // often used for space constrained environments, so it makes sense not to
   // duplicate the ctype table.
   typedef uint16_t char_class_type;
 @@ -2120,7 +2118,7 @@ public:
       __ranges_.push_back(
           std::make_pair(__traits_.transform(__b.begin(), __b.end()), __traits_.transform(__e.begin(), __e.end())));
     } else {
-      if (__b.size() != 1 || __e.size() != 1)
+      if (__b.size() != 1 || __e.size() != 1 || char_traits<typename string_type::value_type>::lt(__e[0], __b[0]))
         std::__throw_regex_error<regex_constants::error_range>();
       if (__icase_) {
         __b[0] = __traits_.translate_nocase(__b[0]);
 @@ -2414,8 +2412,8 @@ public:
 #    endif // _LIBCPP_CXX03_LANG
   // const operations:
-  _LIBCPP_HIDE_FROM_ABI unsigned mark_count() const { return __marked_count_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI unsigned mark_count() const { return __marked_count_; }
-  _LIBCPP_HIDE_FROM_ABI flag_type flags() const { return __flags_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI flag_type flags() const { return __flags_; }
   // locale:
   _LIBCPP_HIDE_FROM_ABI locale_type imbue(locale_type __loc) {
 @@ -2423,7 +2421,7 @@ public:
     __start_.reset();
     return __traits_.imbue(__loc);
   }
-  _LIBCPP_HIDE_FROM_ABI locale_type getloc() const { return __traits_.getloc(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI locale_type getloc() const { return __traits_.getloc(); }
   // swap:
   void swap(basic_regex& __r);
 @@ -4208,17 +4206,17 @@ public:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR sub_match() : matched() {}
-  _LIBCPP_HIDE_FROM_ABI difference_type length() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI difference_type length() const {
     return matched ? std::distance(this->first, this->second) : 0;
   }
-  _LIBCPP_HIDE_FROM_ABI string_type str() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI string_type str() const {
     return matched ? string_type(this->first, this->second) : string_type();
   }
   _LIBCPP_HIDE_FROM_ABI operator string_type() const { return str(); }
-  _LIBCPP_HIDE_FROM_ABI int compare(const sub_match& __s) const { return str().compare(__s.str()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int compare(const sub_match& __s) const { return str().compare(__s.str()); }
-  _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return str().compare(__s); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int compare(const string_type& __s) const { return str().compare(__s); }
-  _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return str().compare(__s); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int compare(const value_type* __s) const { return str().compare(__s); }
   _LIBCPP_HIDE_FROM_ABI void swap(sub_match& __s) _NOEXCEPT_(__is_nothrow_swappable_v<_BidirectionalIterator>) {
     this->pair<_BidirectionalIterator, _BidirectionalIterator>::swap(__s);
 @@ -4583,49 +4581,53 @@ public:
   _LIBCPP_HIDE_FROM_ABI bool ready() const { return __ready_; }
   // size:
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __matches_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __matches_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __matches_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __matches_.max_size(); }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return size() == 0; }
   // element access:
-  _LIBCPP_HIDE_FROM_ABI difference_type length(size_type __sub = 0) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI difference_type length(size_type __sub = 0) const {
     // If the match results are not ready, this will return `0`.
     _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::length() called when not ready");
     return (*this)[__sub].length();
   }
-  _LIBCPP_HIDE_FROM_ABI difference_type position(size_type __sub = 0) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI difference_type position(size_type __sub = 0) const {
     // If the match results are not ready, this will return the result of subtracting two default-constructed iterators
     // (which is typically a well-defined operation).
     _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::position() called when not ready");
     return std::distance(__position_start_, (*this)[__sub].first);
   }
-  _LIBCPP_HIDE_FROM_ABI string_type str(size_type __sub = 0) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI string_type str(size_type __sub = 0) const {
     // If the match results are not ready, this will return an empty string.
     _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::str() called when not ready");
     return (*this)[__sub].str();
   }
-  _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __n) const {
     // If the match results are not ready, this call will be equivalent to calling this function with `__n >= size()`,
     // returning an empty subrange.
     _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::operator[]() called when not ready");
     return __n < __matches_.size() ? __matches_[__n] : __unmatched_;
   }
-  _LIBCPP_HIDE_FROM_ABI const_reference prefix() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference prefix() const {
     // If the match results are not ready, this will return a default-constructed empty `__suffix_`.
     _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::prefix() called when not ready");
     return __prefix_;
   }
-  _LIBCPP_HIDE_FROM_ABI const_reference suffix() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference suffix() const {
     // If the match results are not ready, this will return a default-constructed empty `__suffix_`.
     _LIBCPP_ASSERT_PEDANTIC(ready(), "match_results::suffix() called when not ready");
     return __suffix_;
   }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const { return empty() ? __matches_.end() : __matches_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const {
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __matches_.end(); }
+    return empty() ? __matches_.end() : __matches_.begin();
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const { return empty() ? __matches_.end() : __matches_.begin(); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const { return __matches_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const { return __matches_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const {
+    return empty() ? __matches_.end() : __matches_.begin();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const { return __matches_.end(); }
   // format:
   template <class _OutputIter>
 @@ -4641,14 +4643,14 @@ public:
     return format(__output_iter, __fmt.data(), __fmt.data() + __fmt.size(), __flags);
   }
   template <class _ST, class _SA>
-  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, _ST, _SA>
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_string<char_type, _ST, _SA>
   format(const basic_string<char_type, _ST, _SA>& __fmt,
          regex_constants::match_flag_type __flags = regex_constants::format_default) const {
     basic_string<char_type, _ST, _SA> __r;
     format(std::back_inserter(__r), __fmt.data(), __fmt.data() + __fmt.size(), __flags);
     return __r;
   }
-  _LIBCPP_HIDE_FROM_ABI string_type
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI string_type
   format(const char_type* __fmt, regex_constants::match_flag_type __flags = regex_constants::format_default) const {
     string_type __r;
     format(std::back_inserter(__r), __fmt, __fmt + char_traits<char_type>::length(__fmt), __flags);
 @@ -4656,7 +4658,7 @@ public:
   }
   // allocator:
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return __matches_.get_allocator(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const { return __matches_.get_allocator(); }
   // swap:
   void swap(match_results& __m);
 @@ -5377,7 +5379,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bool operator!=(const regex_iterator& __x) const { return !(*this == __x); }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __match_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference operator*() const { return __match_; }
   _LIBCPP_HIDE_FROM_ABI pointer operator->() const { return std::addressof(__match_); }
   regex_iterator& operator++();
 @@ -5558,7 +5560,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bool operator!=(const regex_token_iterator& __x) const { return !(*this == __x); }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI const value_type& operator*() const { return *__result_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const value_type& operator*() const { return *__result_; }
   _LIBCPP_HIDE_FROM_ABI const value_type* operator->() const { return __result_; }
   regex_token_iterator& operator++();

lib/libcxx/include/scoped_allocator+16-11

 @@ -382,13 +382,17 @@ public:
   // scoped_allocator_adaptor& operator=(scoped_allocator_adaptor&&) = default;
   // ~scoped_allocator_adaptor() = default;
-  _LIBCPP_HIDE_FROM_ABI inner_allocator_type& inner_allocator() _NOEXCEPT { return _Base::inner_allocator(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI inner_allocator_type& inner_allocator() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI const inner_allocator_type& inner_allocator() const _NOEXCEPT {
+    return _Base::inner_allocator();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const inner_allocator_type& inner_allocator() const _NOEXCEPT {
     return _Base::inner_allocator();
   }
-  _LIBCPP_HIDE_FROM_ABI outer_allocator_type& outer_allocator() _NOEXCEPT { return _Base::outer_allocator(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI outer_allocator_type& outer_allocator() _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI const outer_allocator_type& outer_allocator() const _NOEXCEPT {
+    return _Base::outer_allocator();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const outer_allocator_type& outer_allocator() const _NOEXCEPT {
     return _Base::outer_allocator();
   }
 @@ -403,7 +407,7 @@ public:
     allocator_traits<outer_allocator_type>::deallocate(outer_allocator(), __p, __n);
   }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const {
     return allocator_traits<outer_allocator_type>::max_size(outer_allocator());
   }
 @@ -434,10 +438,10 @@ public:
         piecewise_construct,
         __transform_tuple(typename __uses_alloc_ctor< _T1, inner_allocator_type&, _Args1... >::type(),
                           std::move(__x),
-                          typename __make_tuple_indices<sizeof...(_Args1)>::type{}),
+                          __index_sequence_for<_Args1...>()),
         __transform_tuple(typename __uses_alloc_ctor< _T2, inner_allocator_type&, _Args2... >::type(),
                           std::move(__y),
-                          typename __make_tuple_indices<sizeof...(_Args2)>::type{}));
+                          __index_sequence_for<_Args2...>()));
   }
   template <class _T1, class _T2>
 @@ -473,7 +477,8 @@ public:
     allocator_traits<typename _OM::type>::destroy(_OM()(outer_allocator()), __p);
   }
-  _LIBCPP_HIDE_FROM_ABI scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI scoped_allocator_adaptor
+  select_on_container_copy_construction() const _NOEXCEPT {
     return _Base::select_on_container_copy_construction();
   }
 @@ -503,20 +508,20 @@ private:
   template <class... _Args, size_t... _Idx>
   _LIBCPP_HIDE_FROM_ABI tuple<_Args&&...>
-  __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) {
+  __transform_tuple(integral_constant<int, 0>, tuple<_Args...>&& __t, __index_sequence<_Idx...>) {
     return std::forward_as_tuple(std::get<_Idx>(std::move(__t))...);
   }
   template <class... _Args, size_t... _Idx>
   _LIBCPP_HIDE_FROM_ABI tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>
-  __transform_tuple(integral_constant<int, 1>, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) {
+  __transform_tuple(integral_constant<int, 1>, tuple<_Args...>&& __t, __index_sequence<_Idx...>) {
     using _Tup = tuple<allocator_arg_t, inner_allocator_type&, _Args&&...>;
     return _Tup(allocator_arg, inner_allocator(), std::get<_Idx>(std::move(__t))...);
   }
   template <class... _Args, size_t... _Idx>
   _LIBCPP_HIDE_FROM_ABI tuple<_Args&&..., inner_allocator_type&>
-  __transform_tuple(integral_constant<int, 2>, tuple<_Args...>&& __t, __tuple_indices<_Idx...>) {
+  __transform_tuple(integral_constant<int, 2>, tuple<_Args...>&& __t, __index_sequence<_Idx...>) {
     using _Tup = tuple<_Args&&..., inner_allocator_type&>;
     return _Tup(std::get<_Idx>(std::move(__t))..., inner_allocator());
   }

lib/libcxx/include/semaphore+15-18

...	@@ -55,12 +55,11 @@ using binary_semaphore = counting_semaphore<1>; // since C++20	...	@@ -55,12 +55,11 @@ using binary_semaphore = counting_semaphore<1>; // since C++20
55	# include <__assert>	55	# include <__assert>
56	# include <__atomic/atomic.h>	56	# include <__atomic/atomic.h>
57	# include <__atomic/atomic_sync.h>	57	# include <__atomic/atomic_sync.h>
		58	# include <__atomic/atomic_sync_timed.h>
58	# include <__atomic/memory_order.h>	59	# include <__atomic/memory_order.h>
59	# include <__chrono/time_point.h>	60	# include <__chrono/time_point.h>
60	# include <__cstddef/ptrdiff_t.h>	61	# include <__cstddef/ptrdiff_t.h>
61	# include <__thread/poll_with_backoff.h>
62	# include <__thread/support.h>	62	# include <__thread/support.h>
63	# include <__thread/timed_backoff_policy.h>
64	# include <limits>	63	# include <limits>
65	# include <version>	64	# include <version>
66		65
...	@@ -90,7 +89,7 @@ class __atomic_semaphore_base {	...	@@ -90,7 +89,7 @@ class __atomic_semaphore_base {
90		89
91	public:	90	public:
92	_LIBCPP_HIDE_FROM_ABI constexpr explicit __atomic_semaphore_base(ptrdiff_t __count) : __a_(__count) {}	91	_LIBCPP_HIDE_FROM_ABI constexpr explicit __atomic_semaphore_base(ptrdiff_t __count) : __a_(__count) {}
93	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) {	92	_LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) {
94	auto __old = __a_.fetch_add(__update, memory_order_release);	93	auto __old = __a_.fetch_add(__update, memory_order_release);
95	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(	94	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
96	__update <= _LIBCPP_SEMAPHORE_MAX - __old, "update is greater than the expected value");	95	__update <= _LIBCPP_SEMAPHORE_MAX - __old, "update is greater than the expected value");
...	@@ -98,26 +97,26 @@ public:	...	@@ -98,26 +97,26 @@ public:
98	__a_.notify_all();	97	__a_.notify_all();
99	}	98	}
100	}	99	}
101	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void acquire() {	100	_LIBCPP_HIDE_FROM_ABI void acquire() {
102	std::__atomic_wait_unless(__a_, memory_order_relaxed, [this](ptrdiff_t& __old) {	101	std::__atomic_wait_unless(__a_, memory_order_relaxed, [this](ptrdiff_t& __old) {
103	return __try_acquire_impl(__old);	102	return __try_acquire_impl(__old);
104	});	103	});
105	}	104	}
106	template <class _Rep, class _Period>	105	template <class _Rep, class _Period>
107	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool	106	_LIBCPP_HIDE_FROM_ABI bool try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) {
108	try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) {
109	if (__rel_time == chrono::duration<_Rep, _Period>::zero())	107	if (__rel_time == chrono::duration<_Rep, _Period>::zero())
110	return try_acquire();	108	return try_acquire();
111	auto const __poll_fn = [this]() { return try_acquire(); };	109
112	return std::__libcpp_thread_poll_with_backoff(__poll_fn, __libcpp_timed_backoff_policy(), __rel_time);	110	return std::__atomic_wait_unless_with_timeout(
		111	__a_, memory_order_relaxed, [this](ptrdiff_t& __old) { return __try_acquire_impl(__old); }, __rel_time);
113	}	112	}
114	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool try_acquire() {	113	_LIBCPP_HIDE_FROM_ABI bool try_acquire() {
115	auto __old = __a_.load(memory_order_relaxed);	114	auto __old = __a_.load(memory_order_relaxed);
116	return __try_acquire_impl(__old);	115	return __try_acquire_impl(__old);
117	}	116	}
118		117
119	private:	118	private:
120	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __try_acquire_impl(ptrdiff_t& __old) {	119	_LIBCPP_HIDE_FROM_ABI bool __try_acquire_impl(ptrdiff_t& __old) {
121	while (true) {	120	while (true) {
122	if (__old == 0)	121	if (__old == 0)
123	return false;	122	return false;
...	@@ -134,7 +133,7 @@ class counting_semaphore {	...	@@ -134,7 +133,7 @@ class counting_semaphore {
134	public:	133	public:
135	static_assert(__least_max_value >= 0, "The least maximum value must be a positive number");	134	static_assert(__least_max_value >= 0, "The least maximum value must be a positive number");
136		135
137	static constexpr ptrdiff_t max() noexcept { return __least_max_value; }	136	[[nodiscard]] static constexpr ptrdiff_t max() noexcept { return __least_max_value; }
138		137
139	_LIBCPP_HIDE_FROM_ABI constexpr explicit counting_semaphore(ptrdiff_t __count) : __semaphore_(__count) {	138	_LIBCPP_HIDE_FROM_ABI constexpr explicit counting_semaphore(ptrdiff_t __count) : __semaphore_(__count) {
140	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(	139	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(
...	@@ -151,20 +150,18 @@ public:	...	@@ -151,20 +150,18 @@ public:
151	counting_semaphore(const counting_semaphore&) = delete;	150	counting_semaphore(const counting_semaphore&) = delete;
152	counting_semaphore& operator=(const counting_semaphore&) = delete;	151	counting_semaphore& operator=(const counting_semaphore&) = delete;
153		152
154	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) {	153	_LIBCPP_HIDE_FROM_ABI void release(ptrdiff_t __update = 1) {
155	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "counting_semaphore:release called with a negative value");	154	_LIBCPP_ASSERT_ARGUMENT_WITHIN_DOMAIN(__update >= 0, "counting_semaphore:release called with a negative value");
156	__semaphore_.release(__update);	155	__semaphore_.release(__update);
157	}	156	}
158	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void acquire() { __semaphore_.acquire(); }	157	_LIBCPP_HIDE_FROM_ABI void acquire() { __semaphore_.acquire(); }
159	template <class _Rep, class _Period>	158	template <class _Rep, class _Period>
160	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool	159	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) {
161	try_acquire_for(chrono::duration<_Rep, _Period> const& __rel_time) {
162	return __semaphore_.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time));	160	return __semaphore_.try_acquire_for(chrono::duration_cast<chrono::nanoseconds>(__rel_time));
163	}	161	}
164	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool try_acquire() { return __semaphore_.try_acquire(); }	162	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool try_acquire() { return __semaphore_.try_acquire(); }
165	template <class _Clock, class _Duration>	163	template <class _Clock, class _Duration>
166	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool	164	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool try_acquire_until(chrono::time_point<_Clock, _Duration> const& __abs_time) {
167	try_acquire_until(chrono::time_point<_Clock, _Duration> const& __abs_time) {
168	auto const __current = _Clock::now();	165	auto const __current = _Clock::now();
169	if (__current >= __abs_time)	166	if (__current >= __abs_time)
170	return try_acquire();	167	return try_acquire();

lib/libcxx/include/set+220-192

 @@ -518,19 +518,19 @@ erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 #  include <__algorithm/equal.h>
 #  include <__algorithm/lexicographical_compare.h>
 #  include <__algorithm/lexicographical_compare_three_way.h>
+#  include <__algorithm/specialized_algorithms.h>
 #  include <__assert>
 #  include <__config>
 #  include <__functional/is_transparent.h>
 #  include <__functional/operations.h>
-#  include <__fwd/set.h>
 #  include <__iterator/erase_if_container.h>
 #  include <__iterator/iterator_traits.h>
-#  include <__iterator/ranges_iterator_traits.h>
 #  include <__iterator/reverse_iterator.h>
 #  include <__memory/allocator.h>
 #  include <__memory/allocator_traits.h>
 #  include <__memory_resource/polymorphic_allocator.h>
 #  include <__node_handle>
+#  include <__ranges/access.h>
 #  include <__ranges/concepts.h>
 #  include <__ranges/container_compatible_range.h>
 #  include <__ranges/from_range.h>
 @@ -538,7 +538,6 @@ erase_if(multiset<Key, Compare, Allocator>& c, Predicate pred);  // C++20
 #  include <__type_traits/container_traits.h>
 #  include <__type_traits/enable_if.h>
 #  include <__type_traits/is_allocator.h>
-#  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_swappable.h>
 @@ -570,7 +569,10 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <class _Key, class _Compare, class _Allocator>
+template <class _Key, class _Compare = less<_Key>, class _Allocator = allocator<_Key> >
+class multiset;
+template <class _Key, class _Compare = less<_Key>, class _Allocator = allocator<_Key> >
 class set {
 public:
   // types:
 @@ -660,22 +662,20 @@ public:
       : set(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
 #  endif
-  _LIBCPP_HIDE_FROM_ABI set(const set& __s) : __tree_(__s.__tree_) { insert(__s.begin(), __s.end()); }
+  _LIBCPP_HIDE_FROM_ABI set(const set& __s) = default;
   _LIBCPP_HIDE_FROM_ABI set& operator=(const set& __s) = default;
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI set(set&& __s) noexcept(is_nothrow_move_constructible<__base>::value) = default;
+  _LIBCPP_HIDE_FROM_ABI set(set&& __s) = default;
 #  endif // _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI explicit set(const allocator_type& __a) : __tree_(__a) {}
-  _LIBCPP_HIDE_FROM_ABI set(const set& __s, const allocator_type& __a) : __tree_(__s.__tree_.value_comp(), __a) {
+  _LIBCPP_HIDE_FROM_ABI set(const set& __s, const allocator_type& __alloc) : __tree_(__s.__tree_, __alloc) {}
-    insert(__s.begin(), __s.end());
-  }
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI set(set&& __s, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI set(set&& __s, const allocator_type& __alloc) : __tree_(std::move(__s.__tree_), __alloc) {}
   _LIBCPP_HIDE_FROM_ABI set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
       : __tree_(__comp) {
 @@ -693,36 +693,38 @@ public:
 #    endif
   _LIBCPP_HIDE_FROM_ABI set& operator=(initializer_list<value_type> __il) {
-    __tree_.__assign_unique(__il.begin(), __il.end());
+    clear();
+    insert(__il.begin(), __il.end());
     return *this;
   }
-  _LIBCPP_HIDE_FROM_ABI set& operator=(set&& __s) noexcept(is_nothrow_move_assignable<__base>::value) {
+  _LIBCPP_HIDE_FROM_ABI set& operator=(set&& __s) = default;
-    __tree_ = std::move(__s.__tree_);
-    return *this;
-  }
 #  endif // _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI ~set() { static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), ""); }
-  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+    return const_reverse_iterator(end());
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
   // modifiers:
 #  ifndef _LIBCPP_CXX03_LANG
 @@ -732,28 +734,24 @@ public:
   }
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI iterator emplace_hint(const_iterator __p, _Args&&... __args) {
-    return __tree_.__emplace_hint_unique(__p, std::forward<_Args>(__args)...);
+    return __tree_.__emplace_hint_unique(__p, std::forward<_Args>(__args)...).first;
   }
 #  endif // _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __v) { return __tree_.__emplace_unique(__v); }
   _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, const value_type& __v) {
-    return __tree_.__emplace_hint_unique(__p, __v);
+    return __tree_.__emplace_hint_unique(__p, __v).first;
   }
   template <class _InputIterator>
-  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
-    for (const_iterator __e = cend(); __f != __l; ++__f)
+    __tree_.__insert_range_unique(__first, __last);
-      __tree_.__emplace_hint_unique(__e, *__f);
   }
 #  if _LIBCPP_STD_VER >= 23
   template <_ContainerCompatibleRange<value_type> _Range>
   _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
-    const_iterator __end = cend();
+    __tree_.__insert_range_unique(ranges::begin(__range), ranges::end(__range));
-    for (auto&& __element : __range) {
-      __tree_.__emplace_hint_unique(__end, std::forward<decltype(__element)>(__element));
-    }
   }
 #  endif
 @@ -763,7 +761,7 @@ public:
   }
   _LIBCPP_HIDE_FROM_ABI iterator insert(const_iterator __p, value_type&& __v) {
-    return __tree_.__emplace_hint_unique(__p, std::move(__v));
+    return __tree_.__emplace_hint_unique(__p, std::move(__v)).first;
   }
   _LIBCPP_HIDE_FROM_ABI void insert(initializer_list<value_type> __il) { insert(__il.begin(), __il.end()); }
 @@ -785,10 +783,10 @@ public:
                                         "node_type with incompatible allocator passed to set::insert()");
     return __tree_.template __node_handle_insert_unique<node_type>(__hint, std::move(__nh));
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
     return __tree_.template __node_handle_extract<node_type>(__key);
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
     return __tree_.template __node_handle_extract<node_type>(__it);
   }
   template <class _Compare2>
 @@ -819,101 +817,120 @@ public:
   _LIBCPP_HIDE_FROM_ABI void swap(set& __s) _NOEXCEPT_(__is_nothrow_swappable_v<__base>) { __tree_.swap(__s.__tree_); }
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return __tree_.__alloc(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return __tree_.__alloc(); }
-  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp(); }
-  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __tree_.value_comp(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __tree_.value_comp(); }
   // set operations:
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
     return __tree_.find(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
     return __tree_.find(__k);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_unique(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
+    return __tree_.__count_unique(__k);
+  }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
     return __tree_.__count_multi(__k);
   }
 #  endif
 #  if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
     return find(__k) != end();
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) {
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }
+    return __tree_.__lower_bound_unique(__k);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const {
+    return __tree_.__lower_bound_unique(__k);
+  }
+  // The transparent versions of the lookup functions use the _multi version, since a non-element key is allowed to
+  // match multiple elements.
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
-    return __tree_.lower_bound(__k);
+    return __tree_.__lower_bound_multi(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
-    return __tree_.lower_bound(__k);
+    return __tree_.__lower_bound_multi(__k);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) {
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }
+    return __tree_.__upper_bound_unique(__k);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const {
+    return __tree_.__upper_bound_unique(__k);
+  }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
-    return __tree_.upper_bound(__k);
+    return __tree_.__upper_bound_multi(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
-    return __tree_.upper_bound(__k);
+    return __tree_.__upper_bound_multi(__k);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
     return __tree_.__equal_range_unique(__k);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
     return __tree_.__equal_range_unique(__k);
   }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
     return __tree_.__equal_range_multi(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
     return __tree_.__equal_range_multi(__k);
   }
 #  endif
+  template <class, class...>
+  friend struct __specialized_algorithm;
 };
 #  if _LIBCPP_STD_VER >= 17
 template <class _InputIterator,
-          class _Compare   = less<__iter_value_type<_InputIterator>>,
+          class _Compare   = less<__iterator_value_type<_InputIterator>>,
-          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iterator_value_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<__is_allocator_v<_Allocator>>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+          class            = enable_if_t<!__is_allocator_v<_Compare>>>
 set(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
-    -> set<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
+    -> set<__iterator_value_type<_InputIterator>, _Compare, _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Compare   = less<ranges::range_value_t<_Range>>,
           class _Allocator = allocator<ranges::range_value_t<_Range>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<__is_allocator_v<_Allocator>>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+          class            = enable_if_t<!__is_allocator_v<_Compare>>>
 set(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> set<ranges::range_value_t<_Range>, _Compare, _Allocator>;
 #    endif
 @@ -921,41 +938,43 @@ set(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
 template <class _Key,
           class _Compare   = less<_Key>,
           class _Allocator = allocator<_Key>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value, void>,
+          class            = enable_if_t<!__is_allocator_v<_Compare>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value, void>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 set(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator()) -> set<_Key, _Compare, _Allocator>;
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
-set(_InputIterator,
+set(_InputIterator, _InputIterator, _Allocator)
-    _InputIterator,
+    -> set<__iterator_value_type<_InputIterator>, less<__iterator_value_type<_InputIterator>>, _Allocator>;
-    _Allocator) -> set<__iter_value_type<_InputIterator>, less<__iter_value_type<_InputIterator>>, _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
-set(from_range_t,
+set(from_range_t, _Range&&, _Allocator)
-    _Range&&,
+    -> set<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
-    _Allocator) -> set<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
 #    endif
-template <class _Key, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _Key, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 set(initializer_list<_Key>, _Allocator) -> set<_Key, less<_Key>, _Allocator>;
 #  endif
-#  ifndef _LIBCPP_CXX03_LANG
+#  if _LIBCPP_STD_VER >= 14
+template <class _Alg, class _Key, class _Compare, class _Allocator>
+struct __specialized_algorithm<_Alg, __single_range<set<_Key, _Compare, _Allocator>>> {
+  using __set _LIBCPP_NODEBUG = set<_Key, _Compare, _Allocator>;
-template <class _Key, class _Compare, class _Allocator>
+  static const bool __has_algorithm =
-set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a) : __tree_(std::move(__s.__tree_), __a) {
+      __specialized_algorithm<_Alg, __single_range<typename __set::__base>>::__has_algorithm;
-  if (__a != __s.get_allocator()) {
-    const_iterator __e = cend();
-    while (!__s.empty())
-      insert(__e, std::move(__s.__tree_.remove(__s.begin())->__value_));
-  }
-}
-#  endif // _LIBCPP_CXX03_LANG
+  // set's begin() and end() are identical with and without const qualification
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI static auto operator()(const __set& __set, _Args&&... __args) {
+    return __specialized_algorithm<_Alg, __single_range<typename __set::__base>>()(
+        __set.__tree_, std::forward<_Args>(__args)...);
+  }
+};
+#  endif
 template <class _Key, class _Compare, class _Allocator>
 inline _LIBCPP_HIDE_FROM_ABI bool
 @@ -1119,24 +1138,17 @@ public:
       : multiset(from_range, std::forward<_Range>(__range), key_compare(), __a) {}
 #  endif
-  _LIBCPP_HIDE_FROM_ABI multiset(const multiset& __s)
+  _LIBCPP_HIDE_FROM_ABI multiset(const multiset& __s) = default;
-      : __tree_(__s.__tree_.value_comp(),
-                __alloc_traits::select_on_container_copy_construction(__s.__tree_.__alloc())) {
-    insert(__s.begin(), __s.end());
-  }
   _LIBCPP_HIDE_FROM_ABI multiset& operator=(const multiset& __s) = default;
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s) noexcept(is_nothrow_move_constructible<__base>::value) = default;
+  _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s) = default;
-  _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s, const allocator_type& __a);
+  _LIBCPP_HIDE_FROM_ABI multiset(multiset&& __s, const allocator_type& __a) : __tree_(std::move(__s.__tree_), __a) {}
 #  endif // _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI explicit multiset(const allocator_type& __a) : __tree_(__a) {}
-  _LIBCPP_HIDE_FROM_ABI multiset(const multiset& __s, const allocator_type& __a)
+  _LIBCPP_HIDE_FROM_ABI multiset(const multiset& __s, const allocator_type& __a) : __tree_(__s.__tree_, __a) {}
-      : __tree_(__s.__tree_.value_comp(), __a) {
-    insert(__s.begin(), __s.end());
-  }
 #  ifndef _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
 @@ -1156,38 +1168,40 @@ public:
 #    endif
   _LIBCPP_HIDE_FROM_ABI multiset& operator=(initializer_list<value_type> __il) {
-    __tree_.__assign_multi(__il.begin(), __il.end());
+    clear();
+    insert(__il.begin(), __il.end());
     return *this;
   }
-  _LIBCPP_HIDE_FROM_ABI multiset& operator=(multiset&& __s) _NOEXCEPT_(is_nothrow_move_assignable<__base>::value) {
+  _LIBCPP_HIDE_FROM_ABI multiset& operator=(multiset&& __s) = default;
-    __tree_ = std::move(__s.__tree_);
-    return *this;
-  }
 #  endif // _LIBCPP_CXX03_LANG
   _LIBCPP_HIDE_FROM_ABI ~multiset() {
     static_assert(sizeof(std::__diagnose_non_const_comparator<_Key, _Compare>()), "");
   }
-  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __tree_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __tree_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __tree_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __tree_.end(); }
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rbegin() _NOEXCEPT { return reverse_iterator(end()); }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT { return const_reverse_iterator(end()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+    return const_reverse_iterator(end());
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT { return const_reverse_iterator(begin()); }
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reverse_iterator rend() _NOEXCEPT { return reverse_iterator(begin()); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
+    return const_reverse_iterator(begin());
+  }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return end(); }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT { return rbegin(); }
-  _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT { return rend(); }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __tree_.size() == 0; }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __tree_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __tree_.max_size(); }
   // modifiers:
 #  ifndef _LIBCPP_CXX03_LANG
 @@ -1207,18 +1221,14 @@ public:
   }
   template <class _InputIterator>
-  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __f, _InputIterator __l) {
+  _LIBCPP_HIDE_FROM_ABI void insert(_InputIterator __first, _InputIterator __last) {
-    for (const_iterator __e = cend(); __f != __l; ++__f)
+    __tree_.__insert_range_multi(__first, __last);
-      __tree_.__emplace_hint_multi(__e, *__f);
   }
 #  if _LIBCPP_STD_VER >= 23
   template <_ContainerCompatibleRange<value_type> _Range>
   _LIBCPP_HIDE_FROM_ABI void insert_range(_Range&& __range) {
-    const_iterator __end = cend();
+    __tree_.__insert_range_multi(ranges::begin(__range), ranges::end(__range));
-    for (auto&& __element : __range) {
-      __tree_.__emplace_hint_multi(__end, std::forward<decltype(__element)>(__element));
-    }
   }
 #  endif
 @@ -1248,10 +1258,10 @@ public:
                                         "node_type with incompatible allocator passed to multiset::insert()");
     return __tree_.template __node_handle_insert_multi<node_type>(__hint, std::move(__nh));
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
     return __tree_.template __node_handle_extract<node_type>(__key);
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
     return __tree_.template __node_handle_extract<node_type>(__it);
   }
   template <class _Compare2>
 @@ -1284,101 +1294,118 @@ public:
     __tree_.swap(__s.__tree_);
   }
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return __tree_.__alloc(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT { return __tree_.__alloc(); }
-  _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_compare key_comp() const { return __tree_.value_comp(); }
-  _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __tree_.value_comp(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_compare value_comp() const { return __tree_.value_comp(); }
   // set operations:
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __tree_.find(__k); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __tree_.find(__k); }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
     return __tree_.find(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
     return __tree_.find(__k);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __tree_.__count_multi(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
+    return __tree_.__count_multi(__k);
+  }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
     return __tree_.__count_multi(__k);
   }
 #  endif
 #  if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
     return find(__k) != end();
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) { return __tree_.lower_bound(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const key_type& __k) {
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const { return __tree_.lower_bound(__k); }
+    return __tree_.__lower_bound_multi(__k);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const key_type& __k) const {
+    return __tree_.__lower_bound_multi(__k);
+  }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator lower_bound(const _K2& __k) {
-    return __tree_.lower_bound(__k);
+    return __tree_.__lower_bound_multi(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator lower_bound(const _K2& __k) const {
-    return __tree_.lower_bound(__k);
+    return __tree_.__lower_bound_multi(__k);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) { return __tree_.upper_bound(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const key_type& __k) {
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const { return __tree_.upper_bound(__k); }
+    return __tree_.__upper_bound_multi(__k);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const key_type& __k) const {
+    return __tree_.__upper_bound_multi(__k);
+  }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator upper_bound(const _K2& __k) {
-    return __tree_.upper_bound(__k);
+    return __tree_.__upper_bound_multi(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator upper_bound(const _K2& __k) const {
-    return __tree_.upper_bound(__k);
+    return __tree_.__upper_bound_multi(__k);
   }
 #  endif
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
     return __tree_.__equal_range_multi(__k);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
     return __tree_.__equal_range_multi(__k);
   }
 #  if _LIBCPP_STD_VER >= 14
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
     return __tree_.__equal_range_multi(__k);
   }
   template <typename _K2, enable_if_t<__is_transparent_v<_Compare, _K2>, int> = 0>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
     return __tree_.__equal_range_multi(__k);
   }
 #  endif
+  template <class, class...>
+  friend struct __specialized_algorithm;
 };
 #  if _LIBCPP_STD_VER >= 17
 template <class _InputIterator,
-          class _Compare   = less<__iter_value_type<_InputIterator>>,
+          class _Compare   = less<__iterator_value_type<_InputIterator>>,
-          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iterator_value_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<__is_allocator_v<_Allocator>>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+          class            = enable_if_t<!__is_allocator_v<_Compare>>>
 multiset(_InputIterator, _InputIterator, _Compare = _Compare(), _Allocator = _Allocator())
-    -> multiset<__iter_value_type<_InputIterator>, _Compare, _Allocator>;
+    -> multiset<__iterator_value_type<_InputIterator>, _Compare, _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Compare   = less<ranges::range_value_t<_Range>>,
           class _Allocator = allocator<ranges::range_value_t<_Range>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<__is_allocator_v<_Allocator>>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+          class            = enable_if_t<!__is_allocator_v<_Compare>>>
 multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator())
     -> multiset<ranges::range_value_t<_Range>, _Compare, _Allocator>;
 #    endif
 @@ -1386,43 +1413,44 @@ multiset(from_range_t, _Range&&, _Compare = _Compare(), _Allocator = _Allocator(
 template <class _Key,
           class _Compare   = less<_Key>,
           class _Allocator = allocator<_Key>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value, void>,
+          class            = enable_if_t<__is_allocator_v<_Allocator>>,
-          class            = enable_if_t<!__is_allocator<_Compare>::value, void>>
+          class            = enable_if_t<!__is_allocator_v<_Compare>>>
-multiset(initializer_list<_Key>,
+multiset(initializer_list<_Key>, _Compare = _Compare(), _Allocator = _Allocator())
-         _Compare   = _Compare(),
+    -> multiset<_Key, _Compare, _Allocator>;
-         _Allocator = _Allocator()) -> multiset<_Key, _Compare, _Allocator>;
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value, void>,
-          class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 multiset(_InputIterator, _InputIterator, _Allocator)
-    -> multiset<__iter_value_type<_InputIterator>, less<__iter_value_type<_InputIterator>>, _Allocator>;
+    -> multiset<__iterator_value_type<_InputIterator>, less<__iterator_value_type<_InputIterator>>, _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
-multiset(from_range_t,
+multiset(from_range_t, _Range&&, _Allocator)
-         _Range&&,
+    -> multiset<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
-         _Allocator) -> multiset<ranges::range_value_t<_Range>, less<ranges::range_value_t<_Range>>, _Allocator>;
 #    endif
-template <class _Key, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value, void>>
+template <class _Key, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 multiset(initializer_list<_Key>, _Allocator) -> multiset<_Key, less<_Key>, _Allocator>;
 #  endif
-#  ifndef _LIBCPP_CXX03_LANG
+#  if _LIBCPP_STD_VER >= 14
+template <class _Alg, class _Key, class _Compare, class _Allocator>
+struct __specialized_algorithm<_Alg, __single_range<multiset<_Key, _Compare, _Allocator>>> {
+  using __set _LIBCPP_NODEBUG = multiset<_Key, _Compare, _Allocator>;
-template <class _Key, class _Compare, class _Allocator>
+  static const bool __has_algorithm =
-multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
+      __specialized_algorithm<_Alg, __single_range<typename __set::__base>>::__has_algorithm;
-    : __tree_(std::move(__s.__tree_), __a) {
-  if (__a != __s.get_allocator()) {
-    const_iterator __e = cend();
-    while (!__s.empty())
-      insert(__e, std::move(__s.__tree_.remove(__s.begin())->__value_));
-  }
-}
-#  endif // _LIBCPP_CXX03_LANG
+  // set's begin() and end() are identical with and without const qualification
+  template <class... _Args>
+  _LIBCPP_HIDE_FROM_ABI static auto operator()(const __set& __set, _Args&&... __args) {
+    return __specialized_algorithm<_Alg, __single_range<typename __set::__base>>()(
+        __set.__tree_, std::forward<_Args>(__args)...);
+  }
+};
+#  endif
 template <class _Key, class _Compare, class _Allocator>
 inline _LIBCPP_HIDE_FROM_ABI bool

lib/libcxx/include/shared_mutex+3-8

 @@ -138,6 +138,7 @@ template <class Mutex>
 #    include <__mutex/tag_types.h>
 #    include <__mutex/unique_lock.h>
 #    include <__system_error/throw_system_error.h>
+#    include <__utility/move.h>
 #    include <__utility/swap.h>
 #    include <cerrno>
 #    include <version>
 @@ -340,14 +341,8 @@ public:
   }
   _LIBCPP_HIDE_FROM_ABI shared_lock& operator=(shared_lock&& __u) _NOEXCEPT {
-    if (__owns_)
+    if (this != std::addressof(__u))
-      __m_->unlock_shared();
+      shared_lock(std::move(__u)).swap(*this);
-    __m_        = nullptr;
-    __owns_     = false;
-    __m_        = __u.__m_;
-    __owns_     = __u.__owns_;
-    __u.__m_    = nullptr;
-    __u.__owns_ = false;
     return *this;
   }

lib/libcxx/include/span+53-37

 @@ -310,30 +310,32 @@ public:
   }
   template <size_t _Count>
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
     static_assert(_Count <= _Extent, "span<T, N>::first<Count>(): Count out of range");
     return span<element_type, _Count>{data(), _Count};
   }
   template <size_t _Count>
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
     static_assert(_Count <= _Extent, "span<T, N>::last<Count>(): Count out of range");
     return span<element_type, _Count>{data() + size() - _Count, _Count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
+  first(size_type __count) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T, N>::first(count): count out of range");
     return {data(), __count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
+  last(size_type __count) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T, N>::last(count): count out of range");
     return {data() + size() - __count, __count};
   }
   template <size_t _Offset, size_t _Count = dynamic_extent>
-  _LIBCPP_HIDE_FROM_ABI constexpr auto
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto subspan() const noexcept
-  subspan() const noexcept -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset> {
+      -> span<element_type, _Count != dynamic_extent ? _Count : _Extent - _Offset> {
     static_assert(_Offset <= _Extent, "span<T, N>::subspan<Offset, Count>(): Offset out of range");
     static_assert(_Count == dynamic_extent || _Count <= _Extent - _Offset,
                   "span<T, N>::subspan<Offset, Count>(): Offset + Count out of range");
 @@ -342,7 +344,7 @@ public:
     return _ReturnType{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
   subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__offset <= size(), "span<T, N>::subspan(offset, count): offset out of range");
     if (__count == dynamic_extent)
 @@ -352,52 +354,58 @@ public:
     return {data() + __offset, __count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return _Extent; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return _Extent; }
-  _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept { return _Extent * sizeof(element_type); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept {
+    return _Extent * sizeof(element_type);
+  }
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept { return _Extent == 0; }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < size(), "span<T, N>::operator[](index): index out of range");
     return __data_[__idx];
   }
 #    if _LIBCPP_STD_VER >= 26
-  _LIBCPP_HIDE_FROM_ABI constexpr reference at(size_type __index) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference at(size_type __index) const {
     if (__index >= size())
       std::__throw_out_of_range("span");
     return __data_[__index];
   }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T, N>::front() on empty span");
     return __data_[0];
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T, N>::back() on empty span");
     return __data_[size() - 1];
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
   // [span.iter], span iterator support
-  _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
 #    ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
     return std::__make_bounded_iter(data(), data(), data() + size());
 #    else
     return iterator(data());
 #    endif
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
 #    ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
     return std::__make_bounded_iter(data() + size(), data(), data() + size());
 #    else
     return iterator(data() + size());
 #    endif
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
+    return reverse_iterator(end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept {
+    return reverse_iterator(begin());
+  }
   _LIBCPP_HIDE_FROM_ABI span<const byte, _Extent * sizeof(element_type)> __as_bytes() const noexcept {
     return span<const byte, _Extent * sizeof(element_type)>{reinterpret_cast<const byte*>(data()), size_bytes()};
 @@ -478,36 +486,38 @@ public:
       : __data_{__other.data()}, __size_{__other.size()} {}
   template <size_t _Count>
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> first() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count <= size(), "span<T>::first<Count>(): Count out of range");
     return span<element_type, _Count>{data(), _Count};
   }
   template <size_t _Count>
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> last() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count <= size(), "span<T>::last<Count>(): Count out of range");
     return span<element_type, _Count>{data() + size() - _Count, _Count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> first(size_type __count) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
+  first(size_type __count) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T>::first(count): count out of range");
     return {data(), __count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent> last(size_type __count) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, dynamic_extent>
+  last(size_type __count) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__count <= size(), "span<T>::last(count): count out of range");
     return {data() + size() - __count, __count};
   }
   template <size_t _Offset, size_t _Count = dynamic_extent>
-  _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> subspan() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr span<element_type, _Count> subspan() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Offset <= size(), "span<T>::subspan<Offset, Count>(): Offset out of range");
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(_Count == dynamic_extent || _Count <= size() - _Offset,
                                         "span<T>::subspan<Offset, Count>(): Offset + Count out of range");
     return span<element_type, _Count>{data() + _Offset, _Count == dynamic_extent ? size() - _Offset : _Count};
   }
-  constexpr span<element_type, dynamic_extent> _LIBCPP_HIDE_FROM_ABI
+  [[nodiscard]] constexpr span<element_type, dynamic_extent> _LIBCPP_HIDE_FROM_ABI
   subspan(size_type __offset, size_type __count = dynamic_extent) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__offset <= size(), "span<T>::subspan(offset, count): offset out of range");
     if (__count == dynamic_extent)
 @@ -517,52 +527,58 @@ public:
     return {data() + __offset, __count};
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return __size_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_type size() const noexcept { return __size_; }
-  _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept { return __size_ * sizeof(element_type); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_type size_bytes() const noexcept {
+    return __size_ * sizeof(element_type);
+  }
   [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const noexcept { return __size_ == 0; }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference operator[](size_type __idx) const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__idx < size(), "span<T>::operator[](index): index out of range");
     return __data_[__idx];
   }
 #    if _LIBCPP_STD_VER >= 26
-  _LIBCPP_HIDE_FROM_ABI constexpr reference at(size_type __index) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference at(size_type __index) const {
     if (__index >= size())
       std::__throw_out_of_range("span");
     return __data_[__index];
   }
 #    endif
-  _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference front() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T>::front() on empty span");
     return __data_[0];
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reference back() const noexcept {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "span<T>::back() on empty span");
     return __data_[size() - 1];
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr pointer data() const noexcept { return __data_; }
   // [span.iter], span iterator support
-  _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator begin() const noexcept {
 #    ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
     return std::__make_bounded_iter(data(), data(), data() + size());
 #    else
     return iterator(data());
 #    endif
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator end() const noexcept {
 #    ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
     return std::__make_bounded_iter(data() + size(), data(), data() + size());
 #    else
     return iterator(data() + size());
 #    endif
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept { return reverse_iterator(end()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rbegin() const noexcept {
-  _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept { return reverse_iterator(begin()); }
+    return reverse_iterator(end());
+  }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr reverse_iterator rend() const noexcept {
+    return reverse_iterator(begin());
+  }
   _LIBCPP_HIDE_FROM_ABI span<const byte, dynamic_extent> __as_bytes() const noexcept {
     return {reinterpret_cast<const byte*>(data()), size_bytes()};
 @@ -585,13 +601,13 @@ inline constexpr bool ranges::enable_view<span<_ElementType, _Extent>> = true;
 //  as_bytes & as_writable_bytes
 template <class _Tp, size_t _Extent>
-_LIBCPP_HIDE_FROM_ABI auto as_bytes(span<_Tp, _Extent> __s) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI auto as_bytes(span<_Tp, _Extent> __s) noexcept {
   return __s.__as_bytes();
 }
 template <class _Tp, size_t _Extent>
   requires(!is_const_v<_Tp>)
-_LIBCPP_HIDE_FROM_ABI auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI auto as_writable_bytes(span<_Tp, _Extent> __s) noexcept {
   return __s.__as_writable_bytes();
 }

lib/libcxx/include/sstream+34-28

 @@ -461,15 +461,15 @@ public:
   // [stringbuf.members] Member functions:
 #    if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
 #    endif
 #    if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
-  string_type str() const;
+  [[__nodiscard__]] string_type str() const;
 #    else
-  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return str(__str_.get_allocator()); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() const& { return str(__str_.get_allocator()); }
-  _LIBCPP_HIDE_FROM_ABI string_type str() && {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() && {
     const basic_string_view<_CharT, _Traits> __view = view();
     typename string_type::size_type __pos           = __view.empty() ? 0 : __view.data() - __str_.data();
     // In C++23, this is just string_type(std::move(__str_), __pos, __view.size(), __str_.get_allocator());
 @@ -484,12 +484,12 @@ public:
 #    if _LIBCPP_STD_VER >= 20
   template <class _SAlloc>
-    requires __is_allocator<_SAlloc>::value
+    requires __is_allocator_v<_SAlloc>
-  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
     return basic_string<_CharT, _Traits, _SAlloc>(view(), __sa);
   }
-  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept;
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept;
 #    endif // _LIBCPP_STD_VER >= 20
   void str(const string_type& __s) {
 @@ -949,26 +949,28 @@ public:
   }
   // [istringstream.members] Member functions:
-  _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(std::addressof(__sb_));
   }
 #    if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
-  _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
 #    else
-  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
-  _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
 #    endif
 #    if _LIBCPP_STD_VER >= 20
   template <class _SAlloc>
-    requires __is_allocator<_SAlloc>::value
+    requires __is_allocator_v<_SAlloc>
-  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
     return __sb_.str(__sa);
   }
-  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept {
+    return __sb_.view();
+  }
 #    endif // _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI void str(const string_type& __s) { __sb_.str(__s); }
 @@ -1087,26 +1089,28 @@ public:
   }
   // [ostringstream.members] Member functions:
-  _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(std::addressof(__sb_));
   }
 #    if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
-  _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
 #    else
-  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
-  _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
 #    endif
 #    if _LIBCPP_STD_VER >= 20
   template <class _SAlloc>
-    requires __is_allocator<_SAlloc>::value
+    requires __is_allocator_v<_SAlloc>
-  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
     return __sb_.str(__sa);
   }
-  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept {
+    return __sb_.view();
+  }
 #    endif // _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI void str(const string_type& __s) { __sb_.str(__s); }
 @@ -1227,26 +1231,28 @@ public:
   }
   // [stringstream.members] Member functions:
-  _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_stringbuf<char_type, traits_type, allocator_type>* rdbuf() const {
     return const_cast<basic_stringbuf<char_type, traits_type, allocator_type>*>(std::addressof(__sb_));
   }
 #    if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_BUILDING_LIBRARY)
-  _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI string_type str() const { return __sb_.str(); }
 #    else
-  _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() const& { return __sb_.str(); }
-  _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI string_type str() && { return std::move(__sb_).str(); }
 #    endif
 #    if _LIBCPP_STD_VER >= 20
   template <class _SAlloc>
-    requires __is_allocator<_SAlloc>::value
+    requires __is_allocator_v<_SAlloc>
-  _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string<char_type, traits_type, _SAlloc> str(const _SAlloc& __sa) const {
     return __sb_.str(__sa);
   }
-  _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept { return __sb_.view(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI basic_string_view<char_type, traits_type> view() const noexcept {
+    return __sb_.view();
+  }
 #    endif // _LIBCPP_STD_VER >= 20
   _LIBCPP_HIDE_FROM_ABI void str(const string_type& __s) { __sb_.str(__s); }

lib/libcxx/include/stack+13-15

...	@@ -235,9 +235,9 @@ public:	...	@@ -235,9 +235,9 @@ public:
235	# endif	235	# endif
236		236
237	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }	237	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const { return c.empty(); }
238	_LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }	238	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const { return c.size(); }
239	_LIBCPP_HIDE_FROM_ABI reference top() { return c.back(); }	239	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI reference top() { return c.back(); }
240	_LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.back(); }	240	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_reference top() const { return c.back(); }
241		241
242	_LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); }	242	_LIBCPP_HIDE_FROM_ABI void push(const value_type& __v) { c.push_back(__v); }
243	# ifndef _LIBCPP_CXX03_LANG	243	# ifndef _LIBCPP_CXX03_LANG
...	@@ -294,19 +294,19 @@ public:	...	@@ -294,19 +294,19 @@ public:
294	};	294	};
295		295
296	# if _LIBCPP_STD_VER >= 17	296	# if _LIBCPP_STD_VER >= 17
297	template <class _Container, class = enable_if_t<!__is_allocator<_Container>::value> >	297	template <class _Container, class = enable_if_t<!__is_allocator_v<_Container>>>
298	stack(_Container) -> stack<typename _Container::value_type, _Container>;	298	stack(_Container) -> stack<typename _Container::value_type, _Container>;
299		299
300	template <class _Container,	300	template <class _Container,
301	class _Alloc,	301	class _Alloc,
302	class = enable_if_t<!__is_allocator<_Container>::value>,	302	class = enable_if_t<!__is_allocator_v<_Container>>,
303	class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >	303	class = enable_if_t<uses_allocator<_Container, _Alloc>::value> >
304	stack(_Container, _Alloc) -> stack<typename _Container::value_type, _Container>;	304	stack(_Container, _Alloc) -> stack<typename _Container::value_type, _Container>;
305	# endif	305	# endif
306		306
307	# if _LIBCPP_STD_VER >= 23	307	# if _LIBCPP_STD_VER >= 23
308	template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>	308	template <class _InputIterator, __enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0>
309	stack(_InputIterator, _InputIterator) -> stack<__iter_value_type<_InputIterator>>;	309	stack(_InputIterator, _InputIterator) -> stack<__iterator_value_type<_InputIterator>>;
310		310
311	template <ranges::input_range _Range>	311	template <ranges::input_range _Range>
312	stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;	312	stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;
...	@@ -314,15 +314,13 @@ stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;	...	@@ -314,15 +314,13 @@ stack(from_range_t, _Range&&) -> stack<ranges::range_value_t<_Range>>;
314	template <class _InputIterator,	314	template <class _InputIterator,
315	class _Alloc,	315	class _Alloc,
316	__enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,	316	__enable_if_t<__has_input_iterator_category<_InputIterator>::value, int> = 0,
317	__enable_if_t<__is_allocator<_Alloc>::value, int> = 0>	317	__enable_if_t<__is_allocator_v<_Alloc>, int> = 0>
318	stack(_InputIterator,	318	stack(_InputIterator, _InputIterator, _Alloc)
319	_InputIterator,	319	-> stack<__iterator_value_type<_InputIterator>, deque<__iterator_value_type<_InputIterator>, _Alloc>>;
320	_Alloc) -> stack<__iter_value_type<_InputIterator>, deque<__iter_value_type<_InputIterator>, _Alloc>>;	320
321		321	template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator_v<_Alloc>, int> = 0>
322	template <ranges::input_range _Range, class _Alloc, __enable_if_t<__is_allocator<_Alloc>::value, int> = 0>	322	stack(from_range_t, _Range&&, _Alloc)
323	stack(from_range_t,	323	-> stack<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
324	_Range&&,
325	_Alloc) -> stack<ranges::range_value_t<_Range>, deque<ranges::range_value_t<_Range>, _Alloc>>;
326		324
327	# endif	325	# endif
328		326

lib/libcxx/include/stddef.h+10-10

...	@@ -25,24 +25,24 @@ Types:	...	@@ -25,24 +25,24 @@ Types:
25	*/	25	*/
26		26
27	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	27	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
28	# include <__cxx03/stddef.h>	28	# include <__cxx03/__config>
29	#else	29	#else
30	# include <__config>	30	# include <__config>
		31	#endif
31		32
32	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	33	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
33	# pragma GCC system_header	34	# pragma GCC system_header
34	# endif	35	#endif
35		36
36	// Note: This include is outside of header guards because we sometimes get included multiple times	37	// Note: This include is outside of header guards because we sometimes get included multiple times
37	// with different defines and the underlying <stddef.h> will know how to deal with that.	38	// with different defines and the underlying <stddef.h> will know how to deal with that.
38	# include_next <stddef.h>	39	#include_next <stddef.h>
39		40
40	# ifndef _LIBCPP_STDDEF_H	41	#ifndef _LIBCPP_STDDEF_H
41	# define _LIBCPP_STDDEF_H	42	# define _LIBCPP_STDDEF_H
42		43
43	# ifdef __cplusplus	44	# ifdef __cplusplus
44	typedef decltype(nullptr) nullptr_t;	45	typedef decltype(nullptr) nullptr_t;
45	# endif	46	# endif
46	# endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
47		47
48	#endif // _LIBCPP_STDDEF_H	48	#endif // _LIBCPP_STDDEF_H

lib/libcxx/include/stdexcept+2-2

...	@@ -91,7 +91,7 @@ public:	...	@@ -91,7 +91,7 @@ public:
91		91
92	~logic_error() _NOEXCEPT override;	92	~logic_error() _NOEXCEPT override;
93		93
94	const char* what() const _NOEXCEPT override;	94	[[__nodiscard__]] const char* what() const _NOEXCEPT override;
95	# else	95	# else
96		96
97	public:	97	public:
...	@@ -115,7 +115,7 @@ public:	...	@@ -115,7 +115,7 @@ public:
115		115
116	~runtime_error() _NOEXCEPT override;	116	~runtime_error() _NOEXCEPT override;
117		117
118	const char* what() const _NOEXCEPT override;	118	[[__nodiscard__]] const char* what() const _NOEXCEPT override;
119	# else	119	# else
120		120
121	public:	121	public:

lib/libcxx/include/stdio.h+20-21

...	@@ -88,35 +88,34 @@ void perror(const char* s);	...	@@ -88,35 +88,34 @@ void perror(const char* s);
88	*/	88	*/
89		89
90	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	90	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
91	# include <__cxx03/stdio.h>	91	# include <__cxx03/__config>
92	#else	92	#else
93	# include <__config>	93	# include <__config>
		94	#endif
94		95
95	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	96	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
96	# pragma GCC system_header	97	# pragma GCC system_header
97	# endif	98	#endif
98		99
99	// The inclusion of the system's <stdio.h> is intentionally done once outside of any include	100	// The inclusion of the system's <stdio.h> is intentionally done once outside of any include
100	// guards because some code expects to be able to include the underlying system header multiple	101	// guards because some code expects to be able to include the underlying system header multiple
101	// times to get different definitions based on the macros that are set before inclusion.	102	// times to get different definitions based on the macros that are set before inclusion.
102	# if __has_include_next(<stdio.h>)	103	#if __has_include_next(<stdio.h>)
103	# include_next <stdio.h>	104	# include_next <stdio.h>
104	# endif	105	#endif
105		106
106	# ifndef _LIBCPP_STDIO_H	107	#ifndef _LIBCPP_STDIO_H
107	# define _LIBCPP_STDIO_H	108	# define _LIBCPP_STDIO_H
108		109
109	# ifdef __cplusplus	110	# ifdef __cplusplus
110		111
111	# undef getc	112	# undef getc
112	# undef putc	113	# undef putc
113	# undef clearerr	114	# undef clearerr
114	# undef feof	115	# undef feof
115	# undef ferror	116	# undef ferror
116	# undef putchar	117	# undef putchar
117	# undef getchar	118	# undef getchar
118		119
119	# endif // __cplusplus	120	# endif // __cplusplus
120	# endif // _LIBCPP_STDIO_H	121	#endif // _LIBCPP_STDIO_H
121
122	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)

lib/libcxx/include/streambuf+59-19

 @@ -119,6 +119,7 @@ protected:
 #    include <__locale>
 #    include <__type_traits/is_same.h>
 #    include <__utility/is_valid_range.h>
+#    include <__utility/scope_guard.h>
 #    include <climits>
 #    include <ios>
 #    include <iosfwd>
 @@ -149,47 +150,56 @@ public:
   virtual ~basic_streambuf() {}
   // 27.6.2.2.1 locales:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 locale pubimbue(const locale& __loc) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 locale pubimbue(const locale& __loc) {
     imbue(__loc);
     locale __r = __loc_;
     __loc_     = __loc;
     return __r;
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 locale getloc() const { return __loc_; }
+  [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 locale getloc() const { return __loc_; }
   // 27.6.2.2.2 buffer and positioning:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 basic_streambuf* pubsetbuf(char_type* __s, streamsize __n) {
     return setbuf(__s, __n);
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 pos_type
   pubseekoff(off_type __off, ios_base::seekdir __way, ios_base::openmode __which = ios_base::in | ios_base::out) {
     return seekoff(__off, __way, __which);
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 pos_type
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 pos_type
   pubseekpos(pos_type __sp, ios_base::openmode __which = ios_base::in | ios_base::out) {
     return seekpos(__sp, __which);
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int pubsync() { return sync(); }
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int pubsync() { return sync(); }
   // Get and put areas:
   // 27.6.2.2.3 Get area:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize in_avail() {
+  [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 streamsize in_avail() {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (gptr() < egptr())
       return static_cast<streamsize>(egptr() - gptr());
     return showmanyc();
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type snextc() {
+  [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type snextc() {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (sbumpc() == traits_type::eof())
       return traits_type::eof();
     return sgetc();
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sbumpc() {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sbumpc() {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (gptr() == egptr())
       return uflow();
     int_type __c = traits_type::to_int_type(*gptr());
 @@ -197,23 +207,32 @@ public:
     return __c;
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sgetc() {
+  [[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sgetc() {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (gptr() == egptr())
       return underflow();
     return traits_type::to_int_type(*gptr());
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize sgetn(char_type* __s, streamsize __n) { return xsgetn(__s, __n); }
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 streamsize sgetn(char_type* __s, streamsize __n) { return xsgetn(__s, __n); }
   // 27.6.2.2.4 Putback:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sputbackc(char_type __c) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sputbackc(char_type __c) {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (eback() == gptr() || !traits_type::eq(__c, *(gptr() - 1)))
       return pbackfail(traits_type::to_int_type(__c));
     this->gbump(-1);
     return traits_type::to_int_type(*gptr());
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sungetc() {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sungetc() {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (eback() == gptr())
       return pbackfail();
     this->gbump(-1);
 @@ -221,7 +240,10 @@ public:
   }
   // 27.6.2.2.5 Put area:
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 int_type sputc(char_type __c) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 int_type sputc(char_type __c) {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (pptr() == epptr())
       return overflow(traits_type::to_int_type(__c));
     *pptr() = __c;
 @@ -229,7 +251,7 @@ public:
     return traits_type::to_int_type(__c);
   }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 streamsize sputn(const char_type* __s, streamsize __n) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 streamsize sputn(const char_type* __s, streamsize __n) {
     return xsputn(__s, __n);
   }
 @@ -270,12 +292,12 @@ protected:
   _LIBCPP_HIDE_FROM_ABI char_type* gptr() const { return __ninp_; }
   _LIBCPP_HIDE_FROM_ABI char_type* egptr() const { return __einp_; }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void gbump(int __n) { __ninp_ += __n; }
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void gbump(int __n) { __ninp_ += __n; }
   // gbump takes an int, so it might not be able to represent the offset we want to add.
   _LIBCPP_HIDE_FROM_ABI void __gbump_ptrdiff(ptrdiff_t __n) { __ninp_ += __n; }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gnext), "[gbeg, gnext) must be a valid range");
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gbeg, __gend), "[gbeg, gend) must be a valid range");
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__gnext, __gend), "[gnext, gend) must be a valid range");
 @@ -289,11 +311,11 @@ protected:
   _LIBCPP_HIDE_FROM_ABI char_type* pptr() const { return __nout_; }
   _LIBCPP_HIDE_FROM_ABI char_type* epptr() const { return __eout_; }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void pbump(int __n) { __nout_ += __n; }
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void pbump(int __n) { __nout_ += __n; }
   _LIBCPP_HIDE_FROM_ABI void __pbump(streamsize __n) { __nout_ += __n; }
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 void setp(char_type* __pbeg, char_type* __pend) {
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 void setp(char_type* __pbeg, char_type* __pend) {
     _LIBCPP_ASSERT_VALID_INPUT_RANGE(std::__is_valid_range(__pbeg, __pend), "[pbeg, pend) must be a valid range");
     __bout_ = __nout_ = __pbeg;
     __eout_           = __pend;
 @@ -317,6 +339,9 @@ protected:
   virtual streamsize showmanyc() { return 0; }
   virtual streamsize xsgetn(char_type* __s, streamsize __n) {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     int_type __c;
     streamsize __i = 0;
     while (__i < __n) {
 @@ -338,6 +363,9 @@ protected:
   virtual int_type underflow() { return traits_type::eof(); }
   virtual int_type uflow() {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     if (underflow() == traits_type::eof())
       return traits_type::eof();
     int_type __c = traits_type::to_int_type(*gptr());
 @@ -350,6 +378,9 @@ protected:
   // 27.6.2.4.5 Put area:
   virtual streamsize xsputn(const char_type* __s, streamsize __n) {
+    __check_invariants();
+    auto __guard = std::__make_scope_guard([this] { this->__check_invariants(); });
     streamsize __i = 0;
     while (__i < __n) {
       if (pptr() >= epptr()) {
 @@ -370,6 +401,15 @@ protected:
   virtual int_type overflow(int_type = traits_type::eof()) { return traits_type::eof(); }
+  // This function checks some invariants of the class (it isn't exhaustive).
+  _LIBCPP_HIDE_FROM_ABI void __check_invariants() const {
+    _LIBCPP_ASSERT_INTERNAL(pbase() <= pptr(), "this is an invariant of the class");
+    _LIBCPP_ASSERT_INTERNAL(pptr() <= epptr(), "this is an invariant of the class");
+    _LIBCPP_ASSERT_INTERNAL(eback() <= gptr(), "this is an invariant of the class");
+    _LIBCPP_ASSERT_INTERNAL(gptr() <= egptr(), "this is an invariant of the class");
+  }
 private:
   locale __loc_;
   char_type* __binp_ = nullptr;

lib/libcxx/include/string+574-573

...	@@ -280,6 +280,8 @@ public:	...	@@ -280,6 +280,8 @@ public:
280	basic_string substr(size_type pos = 0, size_type n = npos) const; // constexpr in C++20, removed in C++23	280	basic_string substr(size_type pos = 0, size_type n = npos) const; // constexpr in C++20, removed in C++23
281	basic_string substr(size_type pos = 0, size_type n = npos) const&; // since C++23	281	basic_string substr(size_type pos = 0, size_type n = npos) const&; // since C++23
282	constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&; // since C++23	282	constexpr basic_string substr(size_type pos = 0, size_type n = npos) &&; // since C++23
		283	constexpr basic_string_view<charT, traits> subview(size_type pos = 0,
		284	size_type n = npos) const; // since C++26
283	void swap(basic_string& str)	285	void swap(basic_string& str)
284	noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value \|\|	286	noexcept(allocator_traits<allocator_type>::propagate_on_container_swap::value \|\|
285	allocator_traits<allocator_type>::is_always_equal::value); // C++17, constexpr since C++20	287	allocator_traits<allocator_type>::is_always_equal::value); // C++17, constexpr since C++20
...	@@ -598,9 +600,9 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len );	...	@@ -598,9 +600,9 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len );
598	# include <__debug_utils/sanitizers.h>	600	# include <__debug_utils/sanitizers.h>
599	# include <__format/enable_insertable.h>	601	# include <__format/enable_insertable.h>
600	# include <__functional/hash.h>	602	# include <__functional/hash.h>
		603	# include <__functional/is_transparent.h>
601	# include <__functional/unary_function.h>	604	# include <__functional/unary_function.h>
602	# include <__fwd/string.h>	605	# include <__fwd/string.h>
603	# include <__ios/fpos.h>
604	# include <__iterator/bounded_iter.h>	606	# include <__iterator/bounded_iter.h>
605	# include <__iterator/distance.h>	607	# include <__iterator/distance.h>
606	# include <__iterator/iterator_traits.h>	608	# include <__iterator/iterator_traits.h>
...	@@ -620,7 +622,6 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len );	...	@@ -620,7 +622,6 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len );
620	# include <__ranges/concepts.h>	622	# include <__ranges/concepts.h>
621	# include <__ranges/container_compatible_range.h>	623	# include <__ranges/container_compatible_range.h>
622	# include <__ranges/from_range.h>	624	# include <__ranges/from_range.h>
623	# include <__ranges/size.h>
624	# include <__string/char_traits.h>	625	# include <__string/char_traits.h>
625	# include <__string/extern_template_lists.h>	626	# include <__string/extern_template_lists.h>
626	# include <__type_traits/conditional.h>	627	# include <__type_traits/conditional.h>
...	@@ -628,24 +629,23 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len );	...	@@ -628,24 +629,23 @@ basic_string<char32_t> operator""s( const char32_t *str, size_t len );
628	# include <__type_traits/is_allocator.h>	629	# include <__type_traits/is_allocator.h>
629	# include <__type_traits/is_array.h>	630	# include <__type_traits/is_array.h>
630	# include <__type_traits/is_convertible.h>	631	# include <__type_traits/is_convertible.h>
		632	# include <__type_traits/is_generic_transparent_comparator.h>
631	# include <__type_traits/is_nothrow_assignable.h>	633	# include <__type_traits/is_nothrow_assignable.h>
632	# include <__type_traits/is_nothrow_constructible.h>	634	# include <__type_traits/is_nothrow_constructible.h>
633	# include <__type_traits/is_replaceable.h>
634	# include <__type_traits/is_same.h>	635	# include <__type_traits/is_same.h>
635	# include <__type_traits/is_standard_layout.h>	636	# include <__type_traits/is_standard_layout.h>
636	# include <__type_traits/is_trivially_constructible.h>	637	# include <__type_traits/is_trivially_constructible.h>
637	# include <__type_traits/is_trivially_copyable.h>	638	# include <__type_traits/is_trivially_copyable.h>
638	# include <__type_traits/is_trivially_relocatable.h>	639	# include <__type_traits/is_trivially_relocatable.h>
639	# include <__type_traits/remove_cvref.h>	640	# include <__type_traits/remove_cvref.h>
640	# include <__type_traits/void_t.h>	641	# include <__utility/default_three_way_comparator.h>
641	# include <__utility/auto_cast.h>	642	# include <__utility/exception_guard.h>
642	# include <__utility/declval.h>
643	# include <__utility/forward.h>	643	# include <__utility/forward.h>
644	# include <__utility/is_pointer_in_range.h>	644	# include <__utility/is_pointer_in_range.h>
645	# include <__utility/move.h>	645	# include <__utility/move.h>
		646	# include <__utility/no_destroy.h>
646	# include <__utility/scope_guard.h>	647	# include <__utility/scope_guard.h>
647	# include <__utility/swap.h>	648	# include <__utility/swap.h>
648	# include <__utility/unreachable.h>
649	# include <climits>	649	# include <climits>
650	# include <cstdio> // EOF	650	# include <cstdio> // EOF
651	# include <cstring>	651	# include <cstring>
...	@@ -700,18 +700,18 @@ __concatenate_strings(const _Allocator& __alloc,	...	@@ -700,18 +700,18 @@ __concatenate_strings(const _Allocator& __alloc,
700	__type_identity_t<basic_string_view<_CharT, _Traits> > __str2);	700	__type_identity_t<basic_string_view<_CharT, _Traits> > __str2);
701		701
702	template <class _Iter>	702	template <class _Iter>
703	struct __string_is_trivial_iterator : public false_type {};	703	inline const bool __string_is_trivial_iterator_v = false;
704		704
705	template <class _Tp>	705	template <class _Tp>
706	struct __string_is_trivial_iterator<_Tp*> : public is_arithmetic<_Tp> {};	706	inline const bool __string_is_trivial_iterator_v<_Tp*> = is_arithmetic<_Tp>::value;
707		707
708	template <class _Iter>	708	template <class _Iter>
709	struct __string_is_trivial_iterator<__wrap_iter<_Iter> > : public __string_is_trivial_iterator<_Iter> {};	709	inline const bool __string_is_trivial_iterator_v<__wrap_iter<_Iter> > = __string_is_trivial_iterator_v<_Iter>;
710		710
711	template <class _CharT, class _Traits, class _Tp>	711	template <class _CharT, class _Traits, class _Tp>
712	struct __can_be_converted_to_string_view	712	inline const bool __can_be_converted_to_string_view_v =
713	: public _BoolConstant< is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&	713	is_convertible<const _Tp&, basic_string_view<_CharT, _Traits> >::value &&
714	!is_convertible<const _Tp&, const _CharT*>::value > {};	714	!is_convertible<const _Tp&, const _CharT*>::value;
715		715
716	struct __uninitialized_size_tag {};	716	struct __uninitialized_size_tag {};
717	struct __init_with_sentinel_tag {};	717	struct __init_with_sentinel_tag {};
...	@@ -756,20 +756,13 @@ public:	...	@@ -756,20 +756,13 @@ public:
756	// external memory. In such cases, the destructor is responsible for unpoisoning	756	// external memory. In such cases, the destructor is responsible for unpoisoning
757	// the memory to avoid triggering false positives.	757	// the memory to avoid triggering false positives.
758	// Therefore it's crucial to ensure the destructor is called.	758	// Therefore it's crucial to ensure the destructor is called.
759	//	759	using __trivially_relocatable _LIBCPP_NODEBUG = void;
760	// However, it is replaceable since implementing move-assignment as a destroy + move-construct
761	// will maintain the right ASAN state.
762	using __trivially_relocatable = void;
763	# else	760	# else
764	using __trivially_relocatable _LIBCPP_NODEBUG = __conditional_t<	761	using __trivially_relocatable _LIBCPP_NODEBUG = __conditional_t<
765	__libcpp_is_trivially_relocatable<allocator_type>::value && __libcpp_is_trivially_relocatable<pointer>::value,	762	__libcpp_is_trivially_relocatable<allocator_type>::value && __libcpp_is_trivially_relocatable<pointer>::value,
766	basic_string,	763	basic_string,
767	void>;	764	void>;
768	# endif	765	# endif
769	using __replaceable _LIBCPP_NODEBUG =
770	__conditional_t<__is_replaceable_v<pointer> && __container_allocator_is_replaceable<__alloc_traits>::value,
771	basic_string,
772	void>;
773		766
774	# if __has_feature(address_sanitizer) && _LIBCPP_INSTRUMENTED_WITH_ASAN	767	# if __has_feature(address_sanitizer) && _LIBCPP_INSTRUMENTED_WITH_ASAN
775	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __asan_volatile_wrapper(pointer const& __ptr) const {	768	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __asan_volatile_wrapper(pointer const& __ptr) const {
...	@@ -819,12 +812,21 @@ public:	...	@@ -819,12 +812,21 @@ public:
819	using reverse_iterator = std::reverse_iterator<iterator>;	812	using reverse_iterator = std::reverse_iterator<iterator>;
820	using const_reverse_iterator = std::reverse_iterator<const_iterator>;	813	using const_reverse_iterator = std::reverse_iterator<const_iterator>;
821		814
		815	using __alloc_result _LIBCPP_NODEBUG = __allocation_result<pointer, size_type>;
		816
822	private:	817	private:
823	static_assert(CHAR_BIT == 8, "This implementation assumes that one byte contains 8 bits");	818	static_assert(CHAR_BIT == 8, "This implementation assumes that one byte contains 8 bits");
824		819
825	# ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT	820	# ifdef _LIBCPP_ABI_ALTERNATE_STRING_LAYOUT
826		821
827	struct __long {	822	struct __long {
		823	__long() = default;
		824
		825	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __long(__alloc_result __alloc, size_type __size)
		826	: __data_(__alloc.ptr), __size_(__size), __cap_(__alloc.count / __endian_factor), __is_long_(true) {
		827	_LIBCPP_ASSERT_INTERNAL(!__fits_in_sso(__alloc.count), "Long capacity should always be larger than the SSO");
		828	}
		829
828	pointer __data_;	830	pointer __data_;
829	size_type __size_;	831	size_type __size_;
830	size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;	832	size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
...	@@ -872,6 +874,13 @@ private:	...	@@ -872,6 +874,13 @@ private:
872	// some platforms bit fields have a default size rather than the actual	874	// some platforms bit fields have a default size rather than the actual
873	// size used, e.g., it is 4 bytes on AIX. See D128285 for details.	875	// size used, e.g., it is 4 bytes on AIX. See D128285 for details.
874	struct __long {	876	struct __long {
		877	__long() = default;
		878
		879	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __long(__alloc_result __alloc, size_type __size)
		880	: __is_long_(true), __cap_(__alloc.count / __endian_factor), __size_(__size), __data_(__alloc.ptr) {
		881	_LIBCPP_ASSERT_INTERNAL(!__fits_in_sso(__alloc.count), "Long capacity should always be larger than the SSO");
		882	}
		883
875	struct _LIBCPP_PACKED {	884	struct _LIBCPP_PACKED {
876	size_type __is_long_ : 1;	885	size_type __is_long_ : 1;
877	size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;	886	size_type __cap_ : sizeof(size_type) * CHAR_BIT - 1;
...	@@ -898,6 +907,11 @@ private:	...	@@ -898,6 +907,11 @@ private:
898	union __rep {	907	union __rep {
899	__short __s;	908	__short __s;
900	__long __l;	909	__long __l;
		910
		911	__rep() = default;
		912	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __rep(__short __r) : __s(__r) {}
		913	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __rep(__long __r) : __l(__r) {}
		914	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 __rep(__uninitialized_tag) {}
901	};	915	};
902		916
903	_LIBCPP_COMPRESSED_PAIR(__rep, __rep_, allocator_type, __alloc_);	917	_LIBCPP_COMPRESSED_PAIR(__rep, __rep_, allocator_type, __alloc_);
...	@@ -917,20 +931,7 @@ private:	...	@@ -917,20 +931,7 @@ private:
917	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(	931	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(
918	__uninitialized_size_tag, size_type __size, const allocator_type& __a)	932	__uninitialized_size_tag, size_type __size, const allocator_type& __a)
919	: __alloc_(__a) {	933	: __alloc_(__a) {
920	if (__size > max_size())	934	__init_internal_buffer(__size);
921	this->__throw_length_error();
922	if (__fits_in_sso(__size)) {
923	__rep_ = __rep();
924	__set_short_size(__size);
925	} else {
926	auto __capacity = __recommend(__size) + 1;
927	auto __allocation = __alloc_traits::allocate(__alloc_, __capacity);
928	__begin_lifetime(__allocation, __capacity);
929	__set_long_cap(__capacity);
930	__set_long_pointer(__allocation);
931	__set_long_size(__size);
932	}
933	__annotate_new(__size);
934	}	935	}
935		936
936	template <class _Iter, class _Sent>	937	template <class _Iter, class _Sent>
...	@@ -966,7 +967,7 @@ private:	...	@@ -966,7 +967,7 @@ private:
966	std::__wrap_iter<const_pointer>(__get_pointer() + size()));	967	std::__wrap_iter<const_pointer>(__get_pointer() + size()));
967	# else	968	# else
968	return const_iterator(__p);	969	return const_iterator(__p);
969	# endif // _LIBCPP_ABI_BOUNDED_ITERATORS_IN_STRING	970	# endif // _LIBCPP_ABI_BOUNDED_ITERATORS_IN_STRING
970	}	971	}
971		972
972	public:	973	public:
...	@@ -1057,13 +1058,13 @@ public:	...	@@ -1057,13 +1058,13 @@ public:
1057	}	1058	}
1058	# endif // _LIBCPP_CXX03_LANG	1059	# endif // _LIBCPP_CXX03_LANG
1059		1060
1060	template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>	1061	template <__enable_if_t<__is_allocator_v<_Allocator>, int> = 0>
1061	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s) {	1062	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s) {
1062	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "basic_string(const char*) detected nullptr");	1063	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "basic_string(const char*) detected nullptr");
1063	__init(__s, traits_type::length(__s));	1064	__init(__s, traits_type::length(__s));
1064	}	1065	}
1065		1066
1066	template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>	1067	template <__enable_if_t<__is_allocator_v<_Allocator>, int> = 0>
1067	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20	1068	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
1068	basic_string(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, const _Allocator& __a)	1069	basic_string(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, const _Allocator& __a)
1069	: __alloc_(__a) {	1070	: __alloc_(__a) {
...	@@ -1075,13 +1076,15 @@ public:	...	@@ -1075,13 +1076,15 @@ public:
1075	basic_string(nullptr_t) = delete;	1076	basic_string(nullptr_t) = delete;
1076	# endif	1077	# endif
1077		1078
1078	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, size_type __n) {	1079	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(const _CharT* __s, size_type __n)
		1080	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1079	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n) detected nullptr");	1081	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n) detected nullptr");
1080	__init(__s, __n);	1082	__init(__s, __n);
1081	}	1083	}
1082		1084
1083	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20	1085	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
1084	basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)	1086	basic_string(const _CharT* __s, size_type __n, const _Allocator& __a)
		1087	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero")
1085	: __alloc_(__a) {	1088	: __alloc_(__a) {
1086	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");	1089	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "basic_string(const char*, n, allocator) detected nullptr");
1087	__init(__s, __n);	1090	__init(__s, __n);
...	@@ -1110,7 +1113,7 @@ public:	...	@@ -1110,7 +1113,7 @@ public:
1110	}	1113	}
1111	# endif	1114	# endif
1112		1115
1113	template <__enable_if_t<__is_allocator<_Allocator>::value, int> = 0>	1116	template <__enable_if_t<__is_allocator_v<_Allocator>, int> = 0>
1114	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c, const _Allocator& __a)	1117	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string(size_type __n, _CharT __c, const _Allocator& __a)
1115	: __alloc_(__a) {	1118	: __alloc_(__a) {
1116	__init(__n, __c);	1119	__init(__n, __c);
...	@@ -1135,7 +1138,7 @@ public:	...	@@ -1135,7 +1138,7 @@ public:
1135	}	1138	}
1136		1139
1137	template <class _Tp,	1140	template <class _Tp,
1138	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1141	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1139	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1142	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1140	int> = 0>	1143	int> = 0>
1141	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20	1144	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20
...	@@ -1147,7 +1150,7 @@ public:	...	@@ -1147,7 +1150,7 @@ public:
1147	}	1150	}
1148		1151
1149	template <class _Tp,	1152	template <class _Tp,
1150	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1153	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1151	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1154	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1152	int> = 0>	1155	int> = 0>
1153	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(const _Tp& __t) {	1156	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(const _Tp& __t) {
...	@@ -1156,7 +1159,7 @@ public:	...	@@ -1156,7 +1159,7 @@ public:
1156	}	1159	}
1157		1160
1158	template <class _Tp,	1161	template <class _Tp,
1159	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1162	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1160	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1163	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1161	int> = 0>	1164	int> = 0>
1162	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(const _Tp& __t, const allocator_type& __a)	1165	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit basic_string(const _Tp& __t, const allocator_type& __a)
...	@@ -1201,11 +1204,10 @@ public:	...	@@ -1201,11 +1204,10 @@ public:
1201	}	1204	}
1202	# endif // _LIBCPP_CXX03_LANG	1205	# endif // _LIBCPP_CXX03_LANG
1203		1206
1204	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 ~basic_string() {	1207	// TODO(boomanaiden154): Once we mark this in destructors as dead on return,
1205	__annotate_delete();	1208	// we can use a normal call to __reset_internal_buffer and remove the extra
1206	if (__is_long())	1209	// __rep constructor.
1207	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());	1210	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 ~basic_string() { __reset_internal_buffer(__rep(__uninitialized_tag())); }
1208	}
1209		1211
1210	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator __self_view() const _NOEXCEPT {	1212	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 operator __self_view() const _NOEXCEPT {
1211	return __self_view(typename __self_view::__assume_valid(), data(), size());	1213	return __self_view(typename __self_view::__assume_valid(), data(), size());
...	@@ -1215,7 +1217,7 @@ public:	...	@@ -1215,7 +1217,7 @@ public:
1215	operator=(const basic_string& __str);	1217	operator=(const basic_string& __str);
1216		1218
1217	template <class _Tp,	1219	template <class _Tp,
1218	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1220	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1219	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1221	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1220	int> = 0>	1222	int> = 0>
1221	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const _Tp& __t) {	1223	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(const _Tp& __t) {
...	@@ -1243,45 +1245,55 @@ public:	...	@@ -1243,45 +1245,55 @@ public:
1243	# endif	1245	# endif
1244	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c);	1246	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator=(value_type __c);
1245		1247
1246	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() _NOEXCEPT {	1248	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator begin() _NOEXCEPT {
1247	return __make_iterator(__get_pointer());	1249	return __make_iterator(__get_pointer());
1248	}	1250	}
1249	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator begin() const _NOEXCEPT {	1251	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator begin() const _NOEXCEPT {
1250	return __make_const_iterator(__get_pointer());	1252	return __make_const_iterator(__get_pointer());
1251	}	1253	}
1252	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() _NOEXCEPT {	1254	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 iterator end() _NOEXCEPT {
1253	return __make_iterator(__get_pointer() + size());	1255	return __make_iterator(__get_pointer() + size());
1254	}	1256	}
1255	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator end() const _NOEXCEPT {	1257	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator end() const _NOEXCEPT {
1256	return __make_const_iterator(__get_pointer() + size());	1258	return __make_const_iterator(__get_pointer() + size());
1257	}	1259	}
1258		1260
1259	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rbegin() _NOEXCEPT {	1261	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rbegin() _NOEXCEPT {
1260	return reverse_iterator(end());	1262	return reverse_iterator(end());
1261	}	1263	}
1262	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rbegin() const _NOEXCEPT {	1264	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator
		1265	rbegin() const _NOEXCEPT {
1263	return const_reverse_iterator(end());	1266	return const_reverse_iterator(end());
1264	}	1267	}
1265	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rend() _NOEXCEPT {	1268	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reverse_iterator rend() _NOEXCEPT {
1266	return reverse_iterator(begin());	1269	return reverse_iterator(begin());
1267	}	1270	}
1268	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rend() const _NOEXCEPT {	1271	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator rend() const _NOEXCEPT {
1269	return const_reverse_iterator(begin());	1272	return const_reverse_iterator(begin());
1270	}	1273	}
1271		1274
1272	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cbegin() const _NOEXCEPT { return begin(); }	1275	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cbegin() const _NOEXCEPT {
1273	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cend() const _NOEXCEPT { return end(); }	1276	return begin();
1274	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crbegin() const _NOEXCEPT {	1277	}
		1278	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_iterator cend() const _NOEXCEPT {
		1279	return end();
		1280	}
		1281	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator
		1282	crbegin() const _NOEXCEPT {
1275	return rbegin();	1283	return rbegin();
1276	}	1284	}
1277	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crend() const _NOEXCEPT { return rend(); }	1285	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reverse_iterator crend() const _NOEXCEPT {
		1286	return rend();
		1287	}
1278		1288
1279	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT {	1289	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type size() const _NOEXCEPT {
1280	return __is_long() ? __get_long_size() : __get_short_size();	1290	return __is_long() ? __get_long_size() : __get_short_size();
1281	}	1291	}
1282	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type length() const _NOEXCEPT { return size(); }	1292	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type length() const _NOEXCEPT {
		1293	return size();
		1294	}
1283		1295
1284	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT {	1296	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type max_size() const _NOEXCEPT {
1285	if (size_type __m = __alloc_traits::max_size(__alloc_); __m <= std::numeric_limits<size_type>::max() / 2) {	1297	if (size_type __m = __alloc_traits::max_size(__alloc_); __m <= std::numeric_limits<size_type>::max() / 2) {
1286	size_type __res = __m - __alignment;	1298	size_type __res = __m - __alignment;
1287		1299
...	@@ -1299,7 +1311,7 @@ public:	...	@@ -1299,7 +1311,7 @@ public:
1299	}	1311	}
1300	}	1312	}
1301		1313
1302	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {	1314	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type capacity() const _NOEXCEPT {
1303	return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;	1315	return (__is_long() ? __get_long_cap() : static_cast<size_type>(__min_cap)) - 1;
1304	}	1316	}
1305		1317
...	@@ -1311,13 +1323,19 @@ public:	...	@@ -1311,13 +1323,19 @@ public:
1311	# if _LIBCPP_STD_VER >= 23	1323	# if _LIBCPP_STD_VER >= 23
1312	template <class _Op>	1324	template <class _Op>
1313	_LIBCPP_HIDE_FROM_ABI constexpr void resize_and_overwrite(size_type __n, _Op __op) {	1325	_LIBCPP_HIDE_FROM_ABI constexpr void resize_and_overwrite(size_type __n, _Op __op) {
1314	__resize_default_init(__n);	1326	using __result_type = decltype(std::move(__op)(data(), auto(__n)));
1315	__erase_to_end(std::move(__op)(data(), _LIBCPP_AUTO_CAST(__n)));	1327	static_assert(__integer_like<__result_type>, "Operation return type must be integer-like");
		1328	size_type __sz = size();
		1329	size_type __cap = capacity();
		1330	if (__n > __cap)
		1331	__grow_by_without_replace(__cap, __n - __cap, __sz, __sz, 0);
		1332	__annotate_delete();
		1333	__set_size(__n);
		1334	__annotate_new(__n);
		1335	__erase_to_end(std::move(__op)(data(), auto(__n)));
1316	}	1336	}
1317	# endif	1337	# endif
1318		1338
1319	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __resize_default_init(size_type __n);
1320
1321	# if _LIBCPP_STD_VER < 26 \|\| defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRING_RESERVE)	1339	# if _LIBCPP_STD_VER < 26 \|\| defined(_LIBCPP_ENABLE_CXX26_REMOVED_STRING_RESERVE)
1322	_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve() _NOEXCEPT { shrink_to_fit(); }	1340	_LIBCPP_DEPRECATED_IN_CXX20 _LIBCPP_HIDE_FROM_ABI void reserve() _NOEXCEPT { shrink_to_fit(); }
1323	# endif	1341	# endif
...	@@ -1328,7 +1346,8 @@ public:	...	@@ -1328,7 +1346,8 @@ public:
1328	return size() == 0;	1346	return size() == 0;
1329	}	1347	}
1330		1348
1331	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference operator[](size_type __pos) const _NOEXCEPT {	1349	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference
		1350	operator[](size_type __pos) const _NOEXCEPT {
1332	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos <= size(), "string index out of bounds");	1351	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos <= size(), "string index out of bounds");
1333	if (__builtin_constant_p(__pos) && !__fits_in_sso(__pos)) {	1352	if (__builtin_constant_p(__pos) && !__fits_in_sso(__pos)) {
1334	return *(__get_long_pointer() + __pos);	1353	return *(__get_long_pointer() + __pos);
...	@@ -1336,7 +1355,8 @@ public:	...	@@ -1336,7 +1355,8 @@ public:
1336	return *(data() + __pos);	1355	return *(data() + __pos);
1337	}	1356	}
1338		1357
1339	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference operator[](size_type __pos) _NOEXCEPT {	1358	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference
		1359	operator[](size_type __pos) _NOEXCEPT {
1340	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos <= size(), "string index out of bounds");	1360	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos <= size(), "string index out of bounds");
1341	if (__builtin_constant_p(__pos) && !__fits_in_sso(__pos)) {	1361	if (__builtin_constant_p(__pos) && !__fits_in_sso(__pos)) {
1342	return *(__get_long_pointer() + __pos);	1362	return *(__get_long_pointer() + __pos);
...	@@ -1344,15 +1364,15 @@ public:	...	@@ -1344,15 +1364,15 @@ public:
1344	return *(__get_pointer() + __pos);	1364	return *(__get_pointer() + __pos);
1345	}	1365	}
1346		1366
1347	_LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference at(size_type __n) const;	1367	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference at(size_type __n) const;
1348	_LIBCPP_CONSTEXPR_SINCE_CXX20 reference at(size_type __n);	1368	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 reference at(size_type __n);
1349		1369
1350	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const basic_string& __str) {	1370	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const basic_string& __str) {
1351	return append(__str);	1371	return append(__str);
1352	}	1372	}
1353		1373
1354	template <class _Tp,	1374	template <class _Tp,
1355	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1375	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1356	!is_same<__remove_cvref_t<_Tp>, basic_string >::value,	1376	!is_same<__remove_cvref_t<_Tp>, basic_string >::value,
1357	int> = 0>	1377	int> = 0>
1358	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const _Tp& __t) {	1378	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& operator+=(const _Tp& __t) {
...	@@ -1381,7 +1401,7 @@ public:	...	@@ -1381,7 +1401,7 @@ public:
1381	}	1401	}
1382		1402
1383	template <class _Tp,	1403	template <class _Tp,
1384	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1404	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1385	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1405	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1386	int> = 0>	1406	int> = 0>
1387	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const _Tp& __t) {	1407	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const _Tp& __t) {
...	@@ -1392,7 +1412,7 @@ public:	...	@@ -1392,7 +1412,7 @@ public:
1392	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const basic_string& __str, size_type __pos, size_type __n = npos);	1412	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const basic_string& __str, size_type __pos, size_type __n = npos);
1393		1413
1394	template <class _Tp,	1414	template <class _Tp,
1395	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1415	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1396	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1416	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1397	int> = 0>	1417	int> = 0>
1398	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1418	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
...	@@ -1404,12 +1424,11 @@ public:	...	@@ -1404,12 +1424,11 @@ public:
1404	return append(__sv.data() + __pos, std::min(__n, __sz - __pos));	1424	return append(__sv.data() + __pos, std::min(__n, __sz - __pos));
1405	}	1425	}
1406		1426
1407	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* __s, size_type __n);	1427	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* __s, size_type __n)
		1428	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero");
1408	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s);	1429	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s);
1409	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(size_type __n, value_type __c);	1430	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& append(size_type __n, value_type __c);
1410		1431
1411	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __append_default_init(size_type __n);
1412
1413	template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>	1432	template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
1414	_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1433	_LIBCPP_HIDE_FROM_ABI _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
1415	append(_InputIterator __first, _InputIterator __last) {	1434	append(_InputIterator __first, _InputIterator __last) {
...	@@ -1424,20 +1443,21 @@ public:	...	@@ -1424,20 +1443,21 @@ public:
1424	size_type __sz = size();	1443	size_type __sz = size();
1425	size_type __cap = capacity();	1444	size_type __cap = capacity();
1426	size_type __n = static_cast<size_type>(std::distance(__first, __last));	1445	size_type __n = static_cast<size_type>(std::distance(__first, __last));
1427	if (__n) {	1446	if (__n == 0)
1428	if (__string_is_trivial_iterator<_ForwardIterator>::value && !__addr_in_range(*__first)) {	1447	return *this;
1429	if (__cap - __sz < __n)	1448
1430	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);	1449	if (__string_is_trivial_iterator_v<_ForwardIterator> && !__addr_in_range(*__first)) {
1431	__annotate_increase(__n);	1450	if (__cap - __sz < __n)
1432	auto __end = __copy_non_overlapping_range(__first, __last, std::__to_address(__get_pointer() + __sz));	1451	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
1433	traits_type::assign(*__end, value_type());	1452	__annotate_increase(__n);
1434	__set_size(__sz + __n);	1453	auto __end = __copy_non_overlapping_range(__first, __last, std::__to_address(__get_pointer() + __sz));
1435	} else {	1454	traits_type::assign(*__end, value_type());
1436	const basic_string __temp(__first, __last, __alloc_);	1455	__set_size(__sz + __n);
1437	append(__temp.data(), __temp.size());	1456	return *this;
1438	}	1457	} else {
		1458	const basic_string __temp(__first, __last, __alloc_);
		1459	return append(__temp.data(), __temp.size());
1439	}	1460	}
1440	return *this;
1441	}	1461	}
1442		1462
1443	# if _LIBCPP_STD_VER >= 23	1463	# if _LIBCPP_STD_VER >= 23
...	@@ -1457,27 +1477,27 @@ public:	...	@@ -1457,27 +1477,27 @@ public:
1457	_LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(value_type __c);	1477	_LIBCPP_CONSTEXPR_SINCE_CXX20 void push_back(value_type __c);
1458	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back();	1478	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void pop_back();
1459		1479
1460	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() _NOEXCEPT {	1480	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference front() _NOEXCEPT {
1461	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::front(): string is empty");	1481	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::front(): string is empty");
1462	return *__get_pointer();	1482	return *__get_pointer();
1463	}	1483	}
1464		1484
1465	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const _NOEXCEPT {	1485	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference front() const _NOEXCEPT {
1466	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::front(): string is empty");	1486	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::front(): string is empty");
1467	return *data();	1487	return *data();
1468	}	1488	}
1469		1489
1470	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() _NOEXCEPT {	1490	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 reference back() _NOEXCEPT {
1471	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::back(): string is empty");	1491	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::back(): string is empty");
1472	return *(__get_pointer() + size() - 1);	1492	return *(__get_pointer() + size() - 1);
1473	}	1493	}
1474		1494
1475	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const _NOEXCEPT {	1495	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const_reference back() const _NOEXCEPT {
1476	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::back(): string is empty");	1496	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string::back(): string is empty");
1477	return *(data() + size() - 1);	1497	return *(data() + size() - 1);
1478	}	1498	}
1479		1499
1480	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1500	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1481	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const _Tp& __t) {	1501	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const _Tp& __t) {
1482	__self_view __sv = __t;	1502	__self_view __sv = __t;
1483	return assign(__sv.data(), __sv.size());	1503	return assign(__sv.data(), __sv.size());
...	@@ -1519,7 +1539,7 @@ public:	...	@@ -1519,7 +1539,7 @@ public:
1519	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n = npos);	1539	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const basic_string& __str, size_type __pos, size_type __n = npos);
1520		1540
1521	template <class _Tp,	1541	template <class _Tp,
1522	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1542	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1523	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1543	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1524	int> = 0>	1544	int> = 0>
1525	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1545	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
...	@@ -1531,8 +1551,9 @@ public:	...	@@ -1531,8 +1551,9 @@ public:
1531	return assign(__sv.data() + __pos, std::min(__n, __sz - __pos));	1551	return assign(__sv.data() + __pos, std::min(__n, __sz - __pos));
1532	}	1552	}
1533		1553
1534	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s, size_type __n);	1554	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s, size_type __n)
1535	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* __s);	1555	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero");
		1556	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s);
1536	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(size_type __n, value_type __c);	1557	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& assign(size_type __n, value_type __c);
1537		1558
1538	template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>	1559	template <class _InputIterator, __enable_if_t<__has_exactly_input_iterator_category<_InputIterator>::value, int> = 0>
...	@@ -1545,7 +1566,7 @@ public:	...	@@ -1545,7 +1566,7 @@ public:
1545	template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>	1566	template <class _ForwardIterator, __enable_if_t<__has_forward_iterator_category<_ForwardIterator>::value, int> = 0>
1546	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1567	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
1547	assign(_ForwardIterator __first, _ForwardIterator __last) {	1568	assign(_ForwardIterator __first, _ForwardIterator __last) {
1548	if (__string_is_trivial_iterator<_ForwardIterator>::value) {	1569	if (__string_is_trivial_iterator_v<_ForwardIterator>) {
1549	size_type __n = static_cast<size_type>(std::distance(__first, __last));	1570	size_type __n = static_cast<size_type>(std::distance(__first, __last));
1550	__assign_trivial(__first, __last, __n);	1571	__assign_trivial(__first, __last, __n);
1551	} else {	1572	} else {
...	@@ -1558,7 +1579,7 @@ public:	...	@@ -1558,7 +1579,7 @@ public:
1558	# if _LIBCPP_STD_VER >= 23	1579	# if _LIBCPP_STD_VER >= 23
1559	template <_ContainerCompatibleRange<_CharT> _Range>	1580	template <_ContainerCompatibleRange<_CharT> _Range>
1560	_LIBCPP_HIDE_FROM_ABI constexpr basic_string& assign_range(_Range&& __range) {	1581	_LIBCPP_HIDE_FROM_ABI constexpr basic_string& assign_range(_Range&& __range) {
1561	if constexpr (__string_is_trivial_iterator<ranges::iterator_t<_Range>>::value &&	1582	if constexpr (__string_is_trivial_iterator_v<ranges::iterator_t<_Range>> &&
1562	(ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>)) {	1583	(ranges::forward_range<_Range> \|\| ranges::sized_range<_Range>)) {
1563	size_type __n = static_cast<size_type>(ranges::distance(__range));	1584	size_type __n = static_cast<size_type>(ranges::distance(__range));
1564	__assign_trivial(ranges::begin(__range), ranges::end(__range), __n);	1585	__assign_trivial(ranges::begin(__range), ranges::end(__range), __n);
...	@@ -1582,14 +1603,14 @@ public:	...	@@ -1582,14 +1603,14 @@ public:
1582	return insert(__pos1, __str.data(), __str.size());	1603	return insert(__pos1, __str.data(), __str.size());
1583	}	1604	}
1584		1605
1585	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1606	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1586	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos1, const _Tp& __t) {	1607	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos1, const _Tp& __t) {
1587	__self_view __sv = __t;	1608	__self_view __sv = __t;
1588	return insert(__pos1, __sv.data(), __sv.size());	1609	return insert(__pos1, __sv.data(), __sv.size());
1589	}	1610	}
1590		1611
1591	template <class _Tp,	1612	template <class _Tp,
1592	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1613	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1593	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1614	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1594	int> = 0>	1615	int> = 0>
1595	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1616	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
...	@@ -1603,7 +1624,8 @@ public:	...	@@ -1603,7 +1624,8 @@ public:
1603		1624
1604	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1625	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
1605	insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n = npos);	1626	insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n = npos);
1606	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, const value_type* __s, size_type __n);	1627	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, const value_type* __s, size_type __n)
		1628	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero");
1607	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s);	1629	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s);
1608	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);	1630	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& insert(size_type __pos, size_type __n, value_type __c);
1609	_LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __pos, value_type __c);	1631	_LIBCPP_CONSTEXPR_SINCE_CXX20 iterator insert(const_iterator __pos, value_type __c);
...	@@ -1659,7 +1681,7 @@ public:	...	@@ -1659,7 +1681,7 @@ public:
1659	return replace(__pos1, __n1, __str.data(), __str.size());	1681	return replace(__pos1, __n1, __str.data(), __str.size());
1660	}	1682	}
1661		1683
1662	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1684	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1663	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1685	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
1664	replace(size_type __pos1, size_type __n1, const _Tp& __t) {	1686	replace(size_type __pos1, size_type __n1, const _Tp& __t) {
1665	__self_view __sv = __t;	1687	__self_view __sv = __t;
...	@@ -1670,7 +1692,7 @@ public:	...	@@ -1670,7 +1692,7 @@ public:
1670	replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos);	1692	replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos);
1671		1693
1672	template <class _Tp,	1694	template <class _Tp,
1673	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	1695	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
1674	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	1696	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
1675	int> = 0>	1697	int> = 0>
1676	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1698	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
...	@@ -1683,8 +1705,10 @@ public:	...	@@ -1683,8 +1705,10 @@ public:
1683	}	1705	}
1684		1706
1685	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1707	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
1686	replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2);	1708	replace(size_type __pos, size_type __n1, const value_type* __s, size_type __n2)
1687	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& replace(size_type __pos, size_type __n1, const value_type* __s);	1709	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n2 != 0 && __s == nullptr, " if n2 is not zero");
		1710	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
		1711	replace(size_type __pos, size_type __n1, const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s);
1688	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);	1712	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
1689		1713
1690	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1714	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
...	@@ -1693,7 +1717,7 @@ public:	...	@@ -1693,7 +1717,7 @@ public:
1693	static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __str.data(), __str.size());	1717	static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __str.data(), __str.size());
1694	}	1718	}
1695		1719
1696	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1720	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1697	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&	1721	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string&
1698	replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) {	1722	replace(const_iterator __i1, const_iterator __i2, const _Tp& __t) {
1699	__self_view __sv = __t;	1723	__self_view __sv = __t;
...	@@ -1741,19 +1765,24 @@ public:	...	@@ -1741,19 +1765,24 @@ public:
1741	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;	1765	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type copy(value_type* __s, size_type __n, size_type __pos = 0) const;
1742		1766
1743	# if _LIBCPP_STD_VER <= 20	1767	# if _LIBCPP_STD_VER <= 20
1744	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string	1768	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI
1745	substr(size_type __pos = 0, size_type __n = npos) const {	1769	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string substr(size_type __pos = 0, size_type __n = npos) const {
1746	return basic_string(*this, __pos, __n);	1770	return basic_string(*this, __pos, __n);
1747	}	1771	}
1748	# else	1772	# else
1749	_LIBCPP_HIDE_FROM_ABI constexpr basic_string substr(size_type __pos = 0, size_type __n = npos) const& {	1773	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr basic_string substr(size_type __pos = 0, size_type __n = npos) const& {
1750	return basic_string(*this, __pos, __n);	1774	return basic_string(*this, __pos, __n);
1751	}	1775	}
1752		1776
1753	_LIBCPP_HIDE_FROM_ABI constexpr basic_string substr(size_type __pos = 0, size_type __n = npos) && {	1777	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr basic_string substr(size_type __pos = 0, size_type __n = npos) && {
1754	return basic_string(std::move(*this), __pos, __n);	1778	return basic_string(std::move(*this), __pos, __n);
1755	}	1779	}
1756	# endif	1780	# endif
		1781	# if _LIBCPP_STD_VER >= 26
		1782	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __self_view subview(size_type __pos = 0, size_type __n = npos) const {
		1783	return __self_view(*this).subview(__pos, __n);
		1784	}
		1785	# endif
1757		1786
1758	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(basic_string& __str)	1787	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(basic_string& __str)
1759	# if _LIBCPP_STD_VER >= 14	1788	# if _LIBCPP_STD_VER >= 14
...	@@ -1765,225 +1794,238 @@ public:	...	@@ -1765,225 +1794,238 @@ public:
1765	// [string.ops]	1794	// [string.ops]
1766	// ------------	1795	// ------------
1767		1796
1768	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const value_type* c_str() const _NOEXCEPT { return data(); }	1797	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const value_type* c_str() const _NOEXCEPT {
1769	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const value_type* data() const _NOEXCEPT {	1798	return data();
		1799	}
		1800
		1801	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 const value_type* data() const _NOEXCEPT {
1770	return std::__to_address(__get_pointer());	1802	return std::__to_address(__get_pointer());
1771	}	1803	}
1772	# if _LIBCPP_STD_VER >= 17	1804	# if _LIBCPP_STD_VER >= 17
1773	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 value_type* data() _NOEXCEPT {	1805	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 value_type* data() _NOEXCEPT {
1774	return std::__to_address(__get_pointer());	1806	return std::__to_address(__get_pointer());
1775	}	1807	}
1776	# endif	1808	# endif
1777		1809
1778	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT {	1810	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 allocator_type get_allocator() const _NOEXCEPT {
1779	return __alloc_;	1811	return __alloc_;
1780	}	1812	}
1781		1813
1782	// find	1814	// find
1783		1815
1784	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1816	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1785	find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT {	1817	find(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT {
1786	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __str.data(), __pos, __str.size());	1818	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __str.data(), __pos, __str.size());
1787	}	1819	}
1788		1820
1789	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1821	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1790	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1822	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1791	find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT {	1823	find(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT {
1792	__self_view __sv = __t;	1824	__self_view __sv = __t;
1793	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __sv.data(), __pos, __sv.size());	1825	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __sv.data(), __pos, __sv.size());
1794	}	1826	}
1795		1827
1796	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {	1828	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
		1829	find(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT
		1830	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1797	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find(): received nullptr");	1831	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find(): received nullptr");
1798	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);	1832	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
1799	}	1833	}
1800		1834
1801	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1835	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1802	find(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {	1836	find(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {
1803	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find(): received nullptr");	1837	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find(): received nullptr");
1804	return std::__str_find<value_type, size_type, traits_type, npos>(	1838	return std::__str_find<value_type, size_type, traits_type, npos>(
1805	data(), size(), __s, __pos, traits_type::length(__s));	1839	data(), size(), __s, __pos, traits_type::length(__s));
1806	}	1840	}
1807		1841
1808	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT {	1842	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type find(value_type __c, size_type __pos = 0) const _NOEXCEPT {
1809	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);	1843	return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
1810	}	1844	}
1811		1845
1812	// rfind	1846	// rfind
1813		1847
1814	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1848	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1815	rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT {	1849	rfind(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT {
1816	return std::__str_rfind<value_type, size_type, traits_type, npos>(	1850	return std::__str_rfind<value_type, size_type, traits_type, npos>(
1817	data(), size(), __str.data(), __pos, __str.size());	1851	data(), size(), __str.data(), __pos, __str.size());
1818	}	1852	}
1819		1853
1820	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1854	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1821	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1855	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1822	rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT {	1856	rfind(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT {
1823	__self_view __sv = __t;	1857	__self_view __sv = __t;
1824	return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __sv.data(), __pos, __sv.size());	1858	return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __sv.data(), __pos, __sv.size());
1825	}	1859	}
1826		1860
1827	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {	1861	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
		1862	rfind(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT
		1863	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1828	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::rfind(): received nullptr");	1864	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::rfind(): received nullptr");
1829	return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);	1865	return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
1830	}	1866	}
1831		1867
1832	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1868	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1833	rfind(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {	1869	rfind(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {
1834	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::rfind(): received nullptr");	1870	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::rfind(): received nullptr");
1835	return std::__str_rfind<value_type, size_type, traits_type, npos>(	1871	return std::__str_rfind<value_type, size_type, traits_type, npos>(
1836	data(), size(), __s, __pos, traits_type::length(__s));	1872	data(), size(), __s, __pos, traits_type::length(__s));
1837	}	1873	}
1838		1874
1839	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT {	1875	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
		1876	rfind(value_type __c, size_type __pos = npos) const _NOEXCEPT {
1840	return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);	1877	return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
1841	}	1878	}
1842		1879
1843	// find_first_of	1880	// find_first_of
1844		1881
1845	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1882	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1846	find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT {	1883	find_first_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT {
1847	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(	1884	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
1848	data(), size(), __str.data(), __pos, __str.size());	1885	data(), size(), __str.data(), __pos, __str.size());
1849	}	1886	}
1850		1887
1851	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1888	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1852	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1889	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1853	find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT {	1890	find_first_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT {
1854	__self_view __sv = __t;	1891	__self_view __sv = __t;
1855	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(	1892	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
1856	data(), size(), __sv.data(), __pos, __sv.size());	1893	data(), size(), __sv.data(), __pos, __sv.size());
1857	}	1894	}
1858		1895
1859	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1896	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1860	find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {	1897	find_first_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT
		1898	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1861	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_first_of(): received nullptr");	1899	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_first_of(): received nullptr");
1862	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);	1900	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
1863	}	1901	}
1864		1902
1865	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1903	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1866	find_first_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {	1904	find_first_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {
1867	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_first_of(): received nullptr");	1905	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_first_of(): received nullptr");
1868	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(	1906	return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
1869	data(), size(), __s, __pos, traits_type::length(__s));	1907	data(), size(), __s, __pos, traits_type::length(__s));
1870	}	1908	}
1871		1909
1872	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1910	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1873	find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT {	1911	find_first_of(value_type __c, size_type __pos = 0) const _NOEXCEPT {
1874	return find(__c, __pos);	1912	return find(__c, __pos);
1875	}	1913	}
1876		1914
1877	// find_last_of	1915	// find_last_of
1878		1916
1879	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1917	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1880	find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT {	1918	find_last_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT {
1881	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(	1919	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
1882	data(), size(), __str.data(), __pos, __str.size());	1920	data(), size(), __str.data(), __pos, __str.size());
1883	}	1921	}
1884		1922
1885	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1923	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1886	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1924	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1887	find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT {	1925	find_last_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT {
1888	__self_view __sv = __t;	1926	__self_view __sv = __t;
1889	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(	1927	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
1890	data(), size(), __sv.data(), __pos, __sv.size());	1928	data(), size(), __sv.data(), __pos, __sv.size());
1891	}	1929	}
1892		1930
1893	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1931	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1894	find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {	1932	find_last_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT
		1933	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1895	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_last_of(): received nullptr");	1934	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_last_of(): received nullptr");
1896	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);	1935	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
1897	}	1936	}
1898		1937
1899	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1938	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1900	find_last_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {	1939	find_last_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {
1901	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_last_of(): received nullptr");	1940	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_last_of(): received nullptr");
1902	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(	1941	return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
1903	data(), size(), __s, __pos, traits_type::length(__s));	1942	data(), size(), __s, __pos, traits_type::length(__s));
1904	}	1943	}
1905		1944
1906	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1945	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1907	find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT {	1946	find_last_of(value_type __c, size_type __pos = npos) const _NOEXCEPT {
1908	return rfind(__c, __pos);	1947	return rfind(__c, __pos);
1909	}	1948	}
1910		1949
1911	// find_first_not_of	1950	// find_first_not_of
1912		1951
1913	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1952	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1914	find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT {	1953	find_first_not_of(const basic_string& __str, size_type __pos = 0) const _NOEXCEPT {
1915	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(	1954	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
1916	data(), size(), __str.data(), __pos, __str.size());	1955	data(), size(), __str.data(), __pos, __str.size());
1917	}	1956	}
1918		1957
1919	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1958	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1920	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1959	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1921	find_first_not_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT {	1960	find_first_not_of(const _Tp& __t, size_type __pos = 0) const _NOEXCEPT {
1922	__self_view __sv = __t;	1961	__self_view __sv = __t;
1923	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(	1962	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
1924	data(), size(), __sv.data(), __pos, __sv.size());	1963	data(), size(), __sv.data(), __pos, __sv.size());
1925	}	1964	}
1926		1965
1927	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1966	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1928	find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {	1967	find_first_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT
		1968	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1929	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_first_not_of(): received nullptr");	1969	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_first_not_of(): received nullptr");
1930	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);	1970	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
1931	}	1971	}
1932		1972
1933	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1973	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1934	find_first_not_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {	1974	find_first_not_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {
1935	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_first_not_of(): received nullptr");	1975	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_first_not_of(): received nullptr");
1936	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(	1976	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
1937	data(), size(), __s, __pos, traits_type::length(__s));	1977	data(), size(), __s, __pos, traits_type::length(__s));
1938	}	1978	}
1939		1979
1940	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1980	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1941	find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT {	1981	find_first_not_of(value_type __c, size_type __pos = 0) const _NOEXCEPT {
1942	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);	1982	return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
1943	}	1983	}
1944		1984
1945	// find_last_not_of	1985	// find_last_not_of
1946		1986
1947	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1987	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1948	find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT {	1988	find_last_not_of(const basic_string& __str, size_type __pos = npos) const _NOEXCEPT {
1949	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(	1989	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
1950	data(), size(), __str.data(), __pos, __str.size());	1990	data(), size(), __str.data(), __pos, __str.size());
1951	}	1991	}
1952		1992
1953	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	1993	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1954	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	1994	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1955	find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT {	1995	find_last_not_of(const _Tp& __t, size_type __pos = npos) const _NOEXCEPT {
1956	__self_view __sv = __t;	1996	__self_view __sv = __t;
1957	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(	1997	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
1958	data(), size(), __sv.data(), __pos, __sv.size());	1998	data(), size(), __sv.data(), __pos, __sv.size());
1959	}	1999	}
1960		2000
1961	_LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	2001	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1962	find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT {	2002	find_last_not_of(const value_type* __s, size_type __pos, size_type __n) const _NOEXCEPT
		2003	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
1963	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_last_not_of(): received nullptr");	2004	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::find_last_not_of(): received nullptr");
1964	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);	2005	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
1965	}	2006	}
1966		2007
1967	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	2008	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1968	find_last_not_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {	2009	find_last_not_of(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {
1969	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_last_not_of(): received nullptr");	2010	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::find_last_not_of(): received nullptr");
1970	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(	2011	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
1971	data(), size(), __s, __pos, traits_type::length(__s));	2012	data(), size(), __s, __pos, traits_type::length(__s));
1972	}	2013	}
1973		2014
1974	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type	2015	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
1975	find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT {	2016	find_last_not_of(value_type __c, size_type __pos = npos) const _NOEXCEPT {
1976	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);	2017	return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
1977	}	2018	}
1978		2019
1979	// compare	2020	// compare
1980		2021
1981	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const basic_string& __str) const _NOEXCEPT {	2022	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
		2023	compare(const basic_string& __str) const _NOEXCEPT {
1982	return compare(__self_view(__str));	2024	return compare(__self_view(__str));
1983	}	2025	}
1984		2026
1985	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	2027	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
1986	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const _Tp& __t) const _NOEXCEPT {	2028	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const _Tp& __t) const _NOEXCEPT {
1987	__self_view __sv = __t;	2029	__self_view __sv = __t;
1988	size_t __lhs_sz = size();	2030	size_t __lhs_sz = size();
1989	size_t __rhs_sz = __sv.size();	2031	size_t __rhs_sz = __sv.size();
...	@@ -1997,73 +2039,77 @@ public:	...	@@ -1997,73 +2039,77 @@ public:
1997	return 0;	2039	return 0;
1998	}	2040	}
1999		2041
2000	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value, int> = 0>	2042	template <class _Tp, __enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp>, int> = 0>
2001	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int	2043	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
2002	compare(size_type __pos1, size_type __n1, const _Tp& __t) const {	2044	compare(size_type __pos1, size_type __n1, const _Tp& __t) const {
2003	__self_view __sv = __t;	2045	__self_view __sv = __t;
2004	return compare(__pos1, __n1, __sv.data(), __sv.size());	2046	return compare(__pos1, __n1, __sv.data(), __sv.size());
2005	}	2047	}
2006		2048
2007	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int	2049	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
2008	compare(size_type __pos1, size_type __n1, const basic_string& __str) const {	2050	compare(size_type __pos1, size_type __n1, const basic_string& __str) const {
2009	return compare(__pos1, __n1, __str.data(), __str.size());	2051	return compare(__pos1, __n1, __str.data(), __str.size());
2010	}	2052	}
2011		2053
2012	_LIBCPP_CONSTEXPR_SINCE_CXX20 int	2054	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 int
2013	compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) const {	2055	compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2 = npos) const {
2014	return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);	2056	return compare(__pos1, __n1, __self_view(__str), __pos2, __n2);
2015	}	2057	}
2016		2058
2017	template <class _Tp,	2059	template <class _Tp,
2018	__enable_if_t<__can_be_converted_to_string_view<_CharT, _Traits, _Tp>::value &&	2060	__enable_if_t<__can_be_converted_to_string_view_v<_CharT, _Traits, _Tp> &&
2019	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,	2061	!is_same<__remove_cvref_t<_Tp>, basic_string>::value,
2020	int> = 0>	2062	int> = 0>
2021	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int	2063	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 int
2022	compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2 = npos) const {	2064	compare(size_type __pos1, size_type __n1, const _Tp& __t, size_type __pos2, size_type __n2 = npos) const {
2023	__self_view __sv = __t;	2065	__self_view __sv = __t;
2024	return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));	2066	return __self_view(*this).substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
2025	}	2067	}
2026		2068
2027	_LIBCPP_CONSTEXPR_SINCE_CXX20 int compare(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const _NOEXCEPT {	2069	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 int
		2070	compare(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const _NOEXCEPT {
2028	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::compare(): received nullptr");	2071	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::compare(): received nullptr");
2029	return compare(0, npos, __s, traits_type::length(__s));	2072	return compare(0, npos, __s, traits_type::length(__s));
2030	}	2073	}
2031		2074
2032	_LIBCPP_CONSTEXPR_SINCE_CXX20 int	2075	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 int
2033	compare(size_type __pos1, size_type __n1, const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const {	2076	compare(size_type __pos1, size_type __n1, const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const {
2034	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::compare(): received nullptr");	2077	_LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string::compare(): received nullptr");
2035	return compare(__pos1, __n1, __s, traits_type::length(__s));	2078	return compare(__pos1, __n1, __s, traits_type::length(__s));
2036	}	2079	}
2037		2080
2038	_LIBCPP_CONSTEXPR_SINCE_CXX20 int	2081	[[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX20 int
2039	compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const;	2082	compare(size_type __pos1, size_type __n1, const value_type* __s, size_type __n2) const
		2083	_LIBCPP_DIAGNOSE_NULLPTR_IF(__n2 != 0 && __s == nullptr, " if n2 is not zero");
2040		2084
2041	// starts_with	2085	// starts_with
2042		2086
2043	# if _LIBCPP_STD_VER >= 20	2087	# if _LIBCPP_STD_VER >= 20
2044	constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(__self_view __sv) const noexcept {	2088	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(__self_view __sv) const noexcept {
2045	return __self_view(typename __self_view::__assume_valid(), data(), size()).starts_with(__sv);	2089	return __self_view(typename __self_view::__assume_valid(), data(), size()).starts_with(__sv);
2046	}	2090	}
2047		2091
2048	constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {	2092	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {
2049	return !empty() && _Traits::eq(front(), __c);	2093	return !empty() && _Traits::eq(front(), __c);
2050	}	2094	}
2051		2095
2052	constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const noexcept {	2096	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool
		2097	starts_with(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const noexcept {
2053	return starts_with(__self_view(__s));	2098	return starts_with(__self_view(__s));
2054	}	2099	}
2055		2100
2056	// ends_with	2101	// ends_with
2057		2102
2058	constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(__self_view __sv) const noexcept {	2103	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(__self_view __sv) const noexcept {
2059	return __self_view(typename __self_view::__assume_valid(), data(), size()).ends_with(__sv);	2104	return __self_view(typename __self_view::__assume_valid(), data(), size()).ends_with(__sv);
2060	}	2105	}
2061		2106
2062	constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {	2107	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {
2063	return !empty() && _Traits::eq(back(), __c);	2108	return !empty() && _Traits::eq(back(), __c);
2064	}	2109	}
2065		2110
2066	constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const noexcept {	2111	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool
		2112	ends_with(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const noexcept {
2067	return ends_with(__self_view(__s));	2113	return ends_with(__self_view(__s));
2068	}	2114	}
2069	# endif	2115	# endif
...	@@ -2071,15 +2117,16 @@ public:	...	@@ -2071,15 +2117,16 @@ public:
2071	// contains	2117	// contains
2072		2118
2073	# if _LIBCPP_STD_VER >= 23	2119	# if _LIBCPP_STD_VER >= 23
2074	constexpr _LIBCPP_HIDE_FROM_ABI bool contains(__self_view __sv) const noexcept {	2120	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool contains(__self_view __sv) const noexcept {
2075	return __self_view(typename __self_view::__assume_valid(), data(), size()).contains(__sv);	2121	return __self_view(typename __self_view::__assume_valid(), data(), size()).contains(__sv);
2076	}	2122	}
2077		2123
2078	constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept {	2124	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept {
2079	return __self_view(typename __self_view::__assume_valid(), data(), size()).contains(__c);	2125	return __self_view(typename __self_view::__assume_valid(), data(), size()).contains(__c);
2080	}	2126	}
2081		2127
2082	constexpr _LIBCPP_HIDE_FROM_ABI bool contains(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const {	2128	[[__nodiscard__]] constexpr _LIBCPP_HIDE_FROM_ABI bool
		2129	contains(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const {
2083	return __self_view(typename __self_view::__assume_valid(), data(), size()).contains(__s);	2130	return __self_view(typename __self_view::__assume_valid(), data(), size()).contains(__s);
2084	}	2131	}
2085	# endif	2132	# endif
...	@@ -2095,18 +2142,6 @@ private:	...	@@ -2095,18 +2142,6 @@ private:
2095	return __rep_.__s.__is_long_;	2142	return __rep_.__s.__is_long_;
2096	}	2143	}
2097		2144
2098	static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __begin_lifetime(pointer __begin, size_type __n) {
2099	# if _LIBCPP_STD_VER >= 20
2100	if (__libcpp_is_constant_evaluated()) {
2101	for (size_type __i = 0; __i != __n; ++__i)
2102	std::construct_at(std::addressof(__begin[__i]));
2103	}
2104	# else
2105	(void)__begin;
2106	(void)__n;
2107	# endif // _LIBCPP_STD_VER >= 20
2108	}
2109
2110	_LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) { return __sz < __min_cap; }	2145	_LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI static bool __fits_in_sso(size_type __sz) { return __sz < __min_cap; }
2111		2146
2112	template <class _Iterator, class _Sentinel>	2147	template <class _Iterator, class _Sentinel>
...	@@ -2165,6 +2200,9 @@ private:	...	@@ -2165,6 +2200,9 @@ private:
2165	_LIBCPP_CONSTEXPR_SINCE_CXX20 iterator	2200	_LIBCPP_CONSTEXPR_SINCE_CXX20 iterator
2166	__insert_with_size(const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n);	2201	__insert_with_size(const_iterator __pos, _Iterator __first, _Sentinel __last, size_type __n);
2167		2202
		2203	// internal buffer accessors
		2204	// -------------------------
		2205
2168	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS void	2206	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_STRING_INTERNAL_MEMORY_ACCESS void
2169	__set_short_size(size_type __s) _NOEXCEPT {	2207	__set_short_size(size_type __s) _NOEXCEPT {
2170	_LIBCPP_ASSERT_INTERNAL(__s < __min_cap, "__s should never be greater than or equal to the short string capacity");	2208	_LIBCPP_ASSERT_INTERNAL(__s < __min_cap, "__s should never be greater than or equal to the short string capacity");
...	@@ -2194,21 +2232,11 @@ private:	...	@@ -2194,21 +2232,11 @@ private:
2194	__set_short_size(__s);	2232	__set_short_size(__s);
2195	}	2233	}
2196		2234
2197	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_long_cap(size_type __s) _NOEXCEPT {
2198	_LIBCPP_ASSERT_INTERNAL(!__fits_in_sso(__s), "Long capacity should always be larger than the SSO");
2199	__rep_.__l.__cap_ = __s / __endian_factor;
2200	__rep_.__l.__is_long_ = true;
2201	}
2202
2203	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __get_long_cap() const _NOEXCEPT {	2235	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __get_long_cap() const _NOEXCEPT {
2204	_LIBCPP_ASSERT_INTERNAL(__rep_.__l.__is_long_, "String has to be long when trying to get the long capacity");	2236	_LIBCPP_ASSERT_INTERNAL(__rep_.__l.__is_long_, "String has to be long when trying to get the long capacity");
2205	return __rep_.__l.__cap_ * __endian_factor;	2237	return __rep_.__l.__cap_ * __endian_factor;
2206	}	2238	}
2207		2239
2208	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __set_long_pointer(pointer __p) _NOEXCEPT {
2209	__rep_.__l.__data_ = __p;
2210	}
2211
2212	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __get_long_pointer() _NOEXCEPT {	2240	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __get_long_pointer() _NOEXCEPT {
2213	_LIBCPP_ASSERT_INTERNAL(__rep_.__l.__is_long_, "String has to be long when trying to get the long pointer");	2241	_LIBCPP_ASSERT_INTERNAL(__rep_.__l.__is_long_, "String has to be long when trying to get the long pointer");
2214	return _LIBCPP_ASAN_VOLATILE_WRAPPER(__rep_.__l.__data_);	2242	return _LIBCPP_ASAN_VOLATILE_WRAPPER(__rep_.__l.__data_);
...	@@ -2236,6 +2264,58 @@ private:	...	@@ -2236,6 +2264,58 @@ private:
2236	return __is_long() ? __get_long_pointer() : __get_short_pointer();	2264	return __is_long() ? __get_long_pointer() : __get_short_pointer();
2237	}	2265	}
2238		2266
		2267	// Internal buffer management
		2268	// --------------------------
		2269	//
		2270	// These functions are only responsible for managing the buffer itself, not the value inside the buffer. As such,
		2271	// none of these facilities ensure that there is a null terminator at `data()[size()]`.
		2272
		2273	// Allocate a buffer of __capacity size with __alloc and return it
		2274	_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 __long
		2275	__allocate_long_buffer(_Allocator& __alloc, size_type __capacity) {
		2276	_LIBCPP_ASSERT_INTERNAL(!__fits_in_sso(__capacity),
		2277	"Trying to allocate long buffer for a capacity what would fit into the small buffer");
		2278	auto __buffer = std::__allocate_at_least(__alloc, __align_allocation_size(__capacity));
		2279
		2280	if (__libcpp_is_constant_evaluated()) {
		2281	for (size_type __i = 0; __i != __buffer.count; ++__i)
		2282	std::__construct_at(std::addressof(__buffer.ptr[__i]));
		2283	}
		2284
		2285	return __long(__buffer, __capacity);
		2286	}
		2287
		2288	// Replace the current buffer with __new_rep. Deallocate the old long buffer if it exists.
		2289	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __reset_internal_buffer(__rep __new_rep = __short()) {
		2290	__annotate_delete();
		2291	if (__is_long())
		2292	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());
		2293	__rep_ = __new_rep;
		2294	}
		2295
		2296	// Initialize the internal buffer to hold __size elements
		2297	// The elements and null terminator have to be set by the caller
		2298	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pointer __init_internal_buffer(size_type __size) {
		2299	if (__libcpp_is_constant_evaluated())
		2300	__rep_ = __rep();
		2301
		2302	if (__size > max_size())
		2303	__throw_length_error();
		2304
		2305	if (__fits_in_sso(__size)) {
		2306	__set_short_size(__size);
		2307	__annotate_new(__size);
		2308	return __get_short_pointer();
		2309	} else {
		2310	__rep_.__l = __allocate_long_buffer(__alloc_, __size);
		2311	__annotate_new(__size);
		2312	return __get_long_pointer();
		2313	}
		2314	}
		2315
		2316	// ASan annotation helpers
		2317	// -----------------------
		2318
2239	// The following functions are no-ops outside of AddressSanitizer mode.	2319	// The following functions are no-ops outside of AddressSanitizer mode.
2240	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void	2320	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
2241	__annotate_contiguous_container(const void* __old_mid, const void* __new_mid) const {	2321	__annotate_contiguous_container(const void* __old_mid, const void* __new_mid) const {
...	@@ -2243,7 +2323,7 @@ private:	...	@@ -2243,7 +2323,7 @@ private:
2243	(void)__new_mid;	2323	(void)__new_mid;
2244	# if _LIBCPP_INSTRUMENTED_WITH_ASAN	2324	# if _LIBCPP_INSTRUMENTED_WITH_ASAN
2245	# if defined(__APPLE__)	2325	# if defined(__APPLE__)
2246	// TODO: remove after addressing issue #96099 (https://github.com/llvm/llvm-project/issues/96099)	2326	// TODO: remove after addressing issue #96099 (https://llvm.org/PR96099)
2247	if (!__is_long())	2327	if (!__is_long())
2248	return;	2328	return;
2249	# endif	2329	# endif
...	@@ -2287,19 +2367,36 @@ private:	...	@@ -2287,19 +2367,36 @@ private:
2287	return (__s + (__a - 1)) & ~(__a - 1);	2367	return (__s + (__a - 1)) & ~(__a - 1);
2288	}	2368	}
2289	enum { __alignment = 8 };	2369	enum { __alignment = 8 };
2290	static _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type __recommend(size_type __s) _NOEXCEPT {	2370
2291	if (__s < __min_cap) {	2371	// This makes sure that we're using a capacity with some extra alignment, since allocators almost always over-align
2292	return static_cast<size_type>(__min_cap) - 1;	2372	// the allocations anyways, improving memory usage. More importantly, this ensures that the lowest bit is never set
2293	}	2373	// if __endian_factor == 2, allowing us to store whether we're in the long string inside the lowest bit.
		2374	_LIBCPP_HIDE_FROM_ABI static _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
		2375	__align_allocation_size(size_type __size) _NOEXCEPT {
		2376	_LIBCPP_ASSERT_INTERNAL(
		2377	!__fits_in_sso(__size), "Trying to align allocation of a size which would fit into the SSO");
2294	const size_type __boundary = sizeof(value_type) < __alignment ? __alignment / sizeof(value_type) : __endian_factor;	2378	const size_type __boundary = sizeof(value_type) < __alignment ? __alignment / sizeof(value_type) : __endian_factor;
2295	size_type __guess = __align_it<__boundary>(__s + 1) - 1;	2379	size_type __guess = __align_it<__boundary>(__size + 1);
2296	if (__guess == __min_cap)	2380	if (__guess == __min_cap + 1)
2297	__guess += __endian_factor;	2381	__guess += __endian_factor;
2298		2382
2299	_LIBCPP_ASSERT_INTERNAL(__guess >= __s, "recommendation is below the requested size");	2383	_LIBCPP_ASSERT_INTERNAL(__guess >= __size, "aligned allocation size is below the requested size");
2300	return __guess;	2384	return __guess;
2301	}	2385	}
2302		2386
		2387	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 size_type
		2388	__get_amortized_growth_capacity(size_type __required_capacity) {
		2389	size_type __max_size = max_size();
		2390	if (__required_capacity > __max_size)
		2391	__throw_length_error();
		2392	size_type __current_cap = capacity();
		2393	_LIBCPP_ASSERT_INTERNAL(
		2394	__current_cap < __required_capacity, "Trying to grow string even though there is enough capacity already?");
		2395	if (__current_cap > __max_size / 2 - __alignment)
		2396	return __max_size;
		2397	return std::max(__required_capacity, 2 * __current_cap);
		2398	}
		2399
2303	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(const value_type* __s, size_type __sz);	2400	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(const value_type* __s, size_type __sz);
2304	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(size_type __n, value_type __c);	2401	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void __init(size_type __n, value_type __c);
2305		2402
...	@@ -2366,7 +2463,8 @@ private:	...	@@ -2366,7 +2463,8 @@ private:
2366		2463
2367	// __erase_external_with_move is invoked for erase() invocations where	2464	// __erase_external_with_move is invoked for erase() invocations where
2368	// `n ~= npos`, likely requiring memory moves on the string data.	2465	// `n ~= npos`, likely requiring memory moves on the string data.
2369	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void __erase_external_with_move(size_type __pos, size_type __n);	2466	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void
		2467	__erase_external_with_move(size_type __pos, size_type __n) _NOEXCEPT;
2370		2468
2371	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const basic_string& __str) {	2469	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __copy_assign_alloc(const basic_string& __str) {
2372	__copy_assign_alloc(	2470	__copy_assign_alloc(
...	@@ -2378,24 +2476,14 @@ private:	...	@@ -2378,24 +2476,14 @@ private:
2378	__alloc_ = __str.__alloc_;	2476	__alloc_ = __str.__alloc_;
2379	else {	2477	else {
2380	if (!__str.__is_long()) {	2478	if (!__str.__is_long()) {
2381	if (__is_long()) {	2479	__reset_internal_buffer();
2382	__annotate_delete();
2383	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());
2384	__rep_ = __rep();
2385	}
2386	__alloc_ = __str.__alloc_;	2480	__alloc_ = __str.__alloc_;
2387	} else {	2481	} else {
2388	__annotate_delete();	2482	__annotate_delete();
2389	auto __guard = std::__make_scope_guard(__annotate_new_size(*this));	2483	auto __guard = std::__make_scope_guard(__annotate_new_size(*this));
2390	allocator_type __a = __str.__alloc_;	2484	auto __alloc = __str.__alloc_;
2391	auto __allocation = std::__allocate_at_least(__a, __str.__get_long_cap());	2485	__reset_internal_buffer(__allocate_long_buffer(__alloc, __str.size()));
2392	__begin_lifetime(__allocation.ptr, __allocation.count);	2486	__alloc_ = std::move(__alloc);
2393	if (__is_long())
2394	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());
2395	__alloc_ = std::move(__a);
2396	__set_long_pointer(__allocation.ptr);
2397	__set_long_cap(__allocation.count);
2398	__set_long_size(__str.__get_long_size());
2399	}	2487	}
2400	}	2488	}
2401	}	2489	}
...	@@ -2507,26 +2595,55 @@ _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, wchar_t)	...	@@ -2507,26 +2595,55 @@ _LIBCPP_STRING_V1_EXTERN_TEMPLATE_LIST(_LIBCPP_DECLARE, wchar_t)
2507	# endif	2595	# endif
2508	# undef _LIBCPP_DECLARE	2596	# undef _LIBCPP_DECLARE
2509		2597
		2598	# if _LIBCPP_STD_VER <= 17 \|\| !__has_builtin(__builtin_lt_synthesizes_from_spaceship)
		2599	template <class _CharT, class _Traits, class _Alloc>
		2600	struct __default_three_way_comparator<basic_string<_CharT, _Traits, _Alloc>, basic_string<_CharT, _Traits, _Alloc> > {
		2601	using __string_t _LIBCPP_NODEBUG = basic_string<_CharT, _Traits, _Alloc>;
		2602
		2603	_LIBCPP_HIDE_FROM_ABI static int operator()(const __string_t& __lhs, const __string_t& __rhs) {
		2604	auto __min_len = std::min(__lhs.size(), __rhs.size());
		2605	auto __ret = _Traits::compare(__lhs.data(), __rhs.data(), __min_len);
		2606	if (__ret == 0)
		2607	return __lhs.size() == __rhs.size() ? 0 : __lhs.size() < __rhs.size() ? -1 : 1;
		2608	return __ret;
		2609	}
		2610	};
		2611	# endif
		2612
		2613	template <class _Comparator, class _CharT, class _Traits, class _Alloc>
		2614	inline const bool __is_transparently_comparable_v<_Comparator,
		2615	basic_string<_CharT, _Traits, _Alloc>,
		2616	const _CharT*,
		2617	__enable_if_t<__is_generic_transparent_comparator_v<_Comparator> > > =
		2618	true;
		2619
		2620	template <class _Comparator, class _CharT, class _Traits, class _Alloc, size_t _Np>
		2621	inline const bool __is_transparently_comparable_v<_Comparator,
		2622	basic_string<_CharT, _Traits, _Alloc>,
		2623	_CharT[_Np],
		2624	__enable_if_t<__is_generic_transparent_comparator_v<_Comparator> > > =
		2625	true;
		2626
2510	# if _LIBCPP_STD_VER >= 17	2627	# if _LIBCPP_STD_VER >= 17
2511	template <class _InputIterator,	2628	template <class _InputIterator,
2512	class _CharT = __iter_value_type<_InputIterator>,	2629	class _CharT = __iterator_value_type<_InputIterator>,
2513	class _Allocator = allocator<_CharT>,	2630	class _Allocator = allocator<_CharT>,
2514	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,	2631	class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
2515	class = enable_if_t<__is_allocator<_Allocator>::value> >	2632	class = enable_if_t<__is_allocator_v<_Allocator>>>
2516	basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())	2633	basic_string(_InputIterator, _InputIterator, _Allocator = _Allocator())
2517	-> basic_string<_CharT, char_traits<_CharT>, _Allocator>;	2634	-> basic_string<_CharT, char_traits<_CharT>, _Allocator>;
2518		2635
2519	template <class _CharT,	2636	template <class _CharT,
2520	class _Traits,	2637	class _Traits,
2521	class _Allocator = allocator<_CharT>,	2638	class _Allocator = allocator<_CharT>,
2522	class = enable_if_t<__is_allocator<_Allocator>::value> >	2639	class = enable_if_t<__is_allocator_v<_Allocator>>>
2523	explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())	2640	explicit basic_string(basic_string_view<_CharT, _Traits>, const _Allocator& = _Allocator())
2524	-> basic_string<_CharT, _Traits, _Allocator>;	2641	-> basic_string<_CharT, _Traits, _Allocator>;
2525		2642
2526	template <class _CharT,	2643	template <class _CharT,
2527	class _Traits,	2644	class _Traits,
2528	class _Allocator = allocator<_CharT>,	2645	class _Allocator = allocator<_CharT>,
2529	class = enable_if_t<__is_allocator<_Allocator>::value>,	2646	class = enable_if_t<__is_allocator_v<_Allocator>>,
2530	class _Sz = typename allocator_traits<_Allocator>::size_type >	2647	class _Sz = typename allocator_traits<_Allocator>::size_type >
2531	basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())	2648	basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _Allocator())
2532	-> basic_string<_CharT, _Traits, _Allocator>;	2649	-> basic_string<_CharT, _Traits, _Allocator>;
...	@@ -2535,7 +2652,7 @@ basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _	...	@@ -2535,7 +2652,7 @@ basic_string(basic_string_view<_CharT, _Traits>, _Sz, _Sz, const _Allocator& = _
2535	# if _LIBCPP_STD_VER >= 23	2652	# if _LIBCPP_STD_VER >= 23
2536	template <ranges::input_range _Range,	2653	template <ranges::input_range _Range,
2537	class _Allocator = allocator<ranges::range_value_t<_Range>>,	2654	class _Allocator = allocator<ranges::range_value_t<_Range>>,
2538	class = enable_if_t<__is_allocator<_Allocator>::value> >	2655	class = enable_if_t<__is_allocator_v<_Allocator>>>
2539	basic_string(from_range_t, _Range&&, _Allocator = _Allocator())	2656	basic_string(from_range_t, _Range&&, _Allocator = _Allocator())
2540	-> basic_string<ranges::range_value_t<_Range>, char_traits<ranges::range_value_t<_Range>>, _Allocator>;	2657	-> basic_string<ranges::range_value_t<_Range>, char_traits<ranges::range_value_t<_Range>>, _Allocator>;
2541	# endif	2658	# endif
...	@@ -2543,73 +2660,23 @@ basic_string(from_range_t, _Range&&, _Allocator = _Allocator())	...	@@ -2543,73 +2660,23 @@ basic_string(from_range_t, _Range&&, _Allocator = _Allocator())
2543	template <class _CharT, class _Traits, class _Allocator>	2660	template <class _CharT, class _Traits, class _Allocator>
2544	_LIBCPP_CONSTEXPR_SINCE_CXX20 void	2661	_LIBCPP_CONSTEXPR_SINCE_CXX20 void
2545	basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) {	2662	basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz) {
2546	if (__libcpp_is_constant_evaluated())	2663	pointer __p = __init_internal_buffer(__sz);
2547	__rep_ = __rep();
2548	if (__sz > max_size())
2549	this->__throw_length_error();
2550	pointer __p;
2551	if (__fits_in_sso(__sz)) {
2552	__set_short_size(__sz);
2553	__p = __get_short_pointer();
2554	} else {
2555	auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__sz) + 1);
2556	__p = __allocation.ptr;
2557	__begin_lifetime(__p, __allocation.count);
2558	__set_long_pointer(__p);
2559	__set_long_cap(__allocation.count);
2560	__set_long_size(__sz);
2561	}
2562	traits_type::copy(std::__to_address(__p), __s, __sz);	2664	traits_type::copy(std::__to_address(__p), __s, __sz);
2563	traits_type::assign(__p[__sz], value_type());	2665	traits_type::assign(__p[__sz], value_type());
2564	__annotate_new(__sz);
2565	}	2666	}
2566		2667
2567	template <class _CharT, class _Traits, class _Allocator>	2668	template <class _CharT, class _Traits, class _Allocator>
2568	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void	2669	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void
2569	basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(const value_type* __s, size_type __sz) {	2670	basic_string<_CharT, _Traits, _Allocator>::__init_copy_ctor_external(const value_type* __s, size_type __sz) {
2570	if (__libcpp_is_constant_evaluated())	2671	pointer __p = __init_internal_buffer(__sz);
2571	__rep_ = __rep();
2572
2573	pointer __p;
2574	if (__fits_in_sso(__sz)) {
2575	__p = __get_short_pointer();
2576	__set_short_size(__sz);
2577	} else {
2578	if (__sz > max_size())
2579	this->__throw_length_error();
2580	auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__sz) + 1);
2581	__p = __allocation.ptr;
2582	__begin_lifetime(__p, __allocation.count);
2583	__set_long_pointer(__p);
2584	__set_long_cap(__allocation.count);
2585	__set_long_size(__sz);
2586	}
2587	traits_type::copy(std::__to_address(__p), __s, __sz + 1);	2672	traits_type::copy(std::__to_address(__p), __s, __sz + 1);
2588	__annotate_new(__sz);
2589	}	2673	}
2590		2674
2591	template <class _CharT, class _Traits, class _Allocator>	2675	template <class _CharT, class _Traits, class _Allocator>
2592	_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) {	2676	_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c) {
2593	if (__libcpp_is_constant_evaluated())	2677	pointer __p = __init_internal_buffer(__n);
2594	__rep_ = __rep();
2595
2596	if (__n > max_size())
2597	this->__throw_length_error();
2598	pointer __p;
2599	if (__fits_in_sso(__n)) {
2600	__set_short_size(__n);
2601	__p = __get_short_pointer();
2602	} else {
2603	auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__n) + 1);
2604	__p = __allocation.ptr;
2605	__begin_lifetime(__p, __allocation.count);
2606	__set_long_pointer(__p);
2607	__set_long_cap(__allocation.count);
2608	__set_long_size(__n);
2609	}
2610	traits_type::assign(std::__to_address(__p), __n, __c);	2678	traits_type::assign(std::__to_address(__p), __n, __c);
2611	traits_type::assign(__p[__n], value_type());	2679	traits_type::assign(__p[__n], value_type());
2612	__annotate_new(__n);
2613	}	2680	}
2614		2681
2615	template <class _CharT, class _Traits, class _Allocator>	2682	template <class _CharT, class _Traits, class _Allocator>
...	@@ -2626,19 +2693,10 @@ basic_string<_CharT, _Traits, _Allocator>::__init_with_sentinel(_InputIterator _	...	@@ -2626,19 +2693,10 @@ basic_string<_CharT, _Traits, _Allocator>::__init_with_sentinel(_InputIterator _
2626	__rep_ = __rep();	2693	__rep_ = __rep();
2627	__annotate_new(0);	2694	__annotate_new(0);
2628		2695
2629	# if _LIBCPP_HAS_EXCEPTIONS	2696	auto __guard = std::__make_exception_guard([this] { __reset_internal_buffer(); });
2630	try {	2697	for (; __first != __last; ++__first)
2631	# endif // _LIBCPP_HAS_EXCEPTIONS	2698	push_back(*__first);
2632	for (; __first != __last; ++__first)	2699	__guard.__complete();
2633	push_back(*__first);
2634	# if _LIBCPP_HAS_EXCEPTIONS
2635	} catch (...) {
2636	__annotate_delete();
2637	if (__is_long())
2638	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());
2639	throw;
2640	}
2641	# endif // _LIBCPP_HAS_EXCEPTIONS
2642	}	2700	}
2643		2701
2644	template <class _CharT, class _Traits, class _Allocator>	2702	template <class _CharT, class _Traits, class _Allocator>
...	@@ -2653,39 +2711,12 @@ template <class _CharT, class _Traits, class _Allocator>	...	@@ -2653,39 +2711,12 @@ template <class _CharT, class _Traits, class _Allocator>
2653	template <class _InputIterator, class _Sentinel>	2711	template <class _InputIterator, class _Sentinel>
2654	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void	2712	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void
2655	basic_string<_CharT, _Traits, _Allocator>::__init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz) {	2713	basic_string<_CharT, _Traits, _Allocator>::__init_with_size(_InputIterator __first, _Sentinel __last, size_type __sz) {
2656	if (__libcpp_is_constant_evaluated())	2714	pointer __p = __init_internal_buffer(__sz);
2657	__rep_ = __rep();
2658		2715
2659	if (__sz > max_size())	2716	auto __guard = std::__make_exception_guard([this] { __reset_internal_buffer(); });
2660	this->__throw_length_error();	2717	auto __end = __copy_non_overlapping_range(std::move(__first), std::move(__last), std::__to_address(__p));
2661		2718	traits_type::assign(*__end, value_type());
2662	pointer __p;	2719	__guard.__complete();
2663	if (__fits_in_sso(__sz)) {
2664	__set_short_size(__sz);
2665	__p = __get_short_pointer();
2666
2667	} else {
2668	auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__sz) + 1);
2669	__p = __allocation.ptr;
2670	__begin_lifetime(__p, __allocation.count);
2671	__set_long_pointer(__p);
2672	__set_long_cap(__allocation.count);
2673	__set_long_size(__sz);
2674	}
2675
2676	# if _LIBCPP_HAS_EXCEPTIONS
2677	try {
2678	# endif // _LIBCPP_HAS_EXCEPTIONS
2679	auto __end = __copy_non_overlapping_range(std::move(__first), std::move(__last), std::__to_address(__p));
2680	traits_type::assign(*__end, value_type());
2681	# if _LIBCPP_HAS_EXCEPTIONS
2682	} catch (...) {
2683	if (__is_long())
2684	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());
2685	throw;
2686	}
2687	# endif // _LIBCPP_HAS_EXCEPTIONS
2688	__annotate_new(__sz);
2689	}	2720	}
2690		2721
2691	template <class _CharT, class _Traits, class _Allocator>	2722	template <class _CharT, class _Traits, class _Allocator>
...	@@ -2697,32 +2728,22 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__	...	@@ -2697,32 +2728,22 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::__
2697	size_type __n_del,	2728	size_type __n_del,
2698	size_type __n_add,	2729	size_type __n_add,
2699	const value_type* __p_new_stuff) {	2730	const value_type* __p_new_stuff) {
2700	size_type __ms = max_size();	2731	__long __buffer = __allocate_long_buffer(__alloc_, __get_amortized_growth_capacity(__old_cap + __delta_cap));
2701	if (__delta_cap > __ms - __old_cap)
2702	__throw_length_error();
2703	pointer __old_p = __get_pointer();	2732	pointer __old_p = __get_pointer();
2704	size_type __cap =
2705	__old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms;
2706	__annotate_delete();	2733	__annotate_delete();
2707	auto __guard = std::__make_scope_guard(__annotate_new_size(*this));	2734	auto __guard = std::__make_scope_guard(__annotate_new_size(*this));
2708	auto __allocation = std::__allocate_at_least(__alloc_, __cap + 1);
2709	pointer __p = __allocation.ptr;
2710	__begin_lifetime(__p, __allocation.count);
2711	if (__n_copy != 0)	2735	if (__n_copy != 0)
2712	traits_type::copy(std::__to_address(__p), std::__to_address(__old_p), __n_copy);	2736	traits_type::copy(std::__to_address(__buffer.__data_), std::__to_address(__old_p), __n_copy);
2713	if (__n_add != 0)	2737	if (__n_add != 0)
2714	traits_type::copy(std::__to_address(__p) + __n_copy, __p_new_stuff, __n_add);	2738	traits_type::copy(std::__to_address(__buffer.__data_) + __n_copy, __p_new_stuff, __n_add);
2715	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;	2739	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2716	if (__sec_cp_sz != 0)	2740	if (__sec_cp_sz != 0)
2717	traits_type::copy(	2741	traits_type::copy(std::__to_address(__buffer.__data_) + __n_copy + __n_add,
2718	std::__to_address(__p) + __n_copy + __n_add, std::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);	2742	std::__to_address(__old_p) + __n_copy + __n_del,
2719	if (__old_cap + 1 != __min_cap)	2743	__sec_cp_sz);
2720	__alloc_traits::deallocate(__alloc_, __old_p, __old_cap + 1);	2744	__buffer.__size_ = __n_copy + __n_add + __sec_cp_sz;
2721	__set_long_pointer(__p);	2745	traits_type::assign(__buffer.__data_[__buffer.__size_], value_type());
2722	__set_long_cap(__allocation.count);	2746	__reset_internal_buffer(__buffer);
2723	__old_sz = __n_copy + __n_add + __sec_cp_sz;
2724	__set_long_size(__old_sz);
2725	traits_type::assign(__p[__old_sz], value_type());
2726	}	2747	}
2727		2748
2728	// __grow_by is deprecated because it does not set the size. It may not update the size when the size is changed, and it	2749	// __grow_by is deprecated because it does not set the size. It may not update the size when the size is changed, and it
...	@@ -2740,25 +2761,20 @@ _LIBCPP_DEPRECATED_("use __grow_by_without_replace") basic_string<_CharT, _Trait	...	@@ -2740,25 +2761,20 @@ _LIBCPP_DEPRECATED_("use __grow_by_without_replace") basic_string<_CharT, _Trait
2740	size_type __n_copy,	2761	size_type __n_copy,
2741	size_type __n_del,	2762	size_type __n_del,
2742	size_type __n_add) {	2763	size_type __n_add) {
2743	size_type __ms = max_size();	2764	__long __buffer = __allocate_long_buffer(__alloc_, __get_amortized_growth_capacity(__old_cap + __delta_cap));
2744	if (__delta_cap > __ms - __old_cap)
2745	this->__throw_length_error();
2746	pointer __old_p = __get_pointer();	2765	pointer __old_p = __get_pointer();
2747	size_type __cap =
2748	__old_cap < __ms / 2 - __alignment ? __recommend(std::max(__old_cap + __delta_cap, 2 * __old_cap)) : __ms;
2749	auto __allocation = std::__allocate_at_least(__alloc_, __cap + 1);
2750	pointer __p = __allocation.ptr;
2751	__begin_lifetime(__p, __allocation.count);
2752	if (__n_copy != 0)	2766	if (__n_copy != 0)
2753	traits_type::copy(std::__to_address(__p), std::__to_address(__old_p), __n_copy);	2767	traits_type::copy(std::__to_address(__buffer.__data_), std::__to_address(__old_p), __n_copy);
2754	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;	2768	size_type __sec_cp_sz = __old_sz - __n_del - __n_copy;
2755	if (__sec_cp_sz != 0)	2769	if (__sec_cp_sz != 0)
2756	traits_type::copy(	2770	traits_type::copy(std::__to_address(__buffer.__data_) + __n_copy + __n_add,
2757	std::__to_address(__p) + __n_copy + __n_add, std::__to_address(__old_p) + __n_copy + __n_del, __sec_cp_sz);	2771	std::__to_address(__old_p) + __n_copy + __n_del,
2758	if (__old_cap + 1 != __min_cap)	2772	__sec_cp_sz);
2759	__alloc_traits::deallocate(__alloc_, __old_p, __old_cap + 1);	2773
2760	__set_long_pointer(__p);	2774	// This is -1 to make sure the caller sets the size properly, since old versions of this function didn't set the size
2761	__set_long_cap(__allocation.count);	2775	// at all.
		2776	__buffer.__size_ = -1;
		2777	__reset_internal_buffer(__buffer);
2762	}	2778	}
2763		2779
2764	template <class _CharT, class _Traits, class _Allocator>	2780	template <class _CharT, class _Traits, class _Allocator>
...	@@ -2775,6 +2791,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_without_replace(	...	@@ -2775,6 +2791,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_without_replace(
2775	_LIBCPP_SUPPRESS_DEPRECATED_PUSH	2791	_LIBCPP_SUPPRESS_DEPRECATED_PUSH
2776	__grow_by(__old_cap, __delta_cap, __old_sz, __n_copy, __n_del, __n_add);	2792	__grow_by(__old_cap, __delta_cap, __old_sz, __n_copy, __n_del, __n_add);
2777	_LIBCPP_SUPPRESS_DEPRECATED_POP	2793	_LIBCPP_SUPPRESS_DEPRECATED_POP
		2794	// Due to the ABI of __grow_by we have to set the size after calling it.
2778	__set_long_size(__old_sz - __n_del + __n_add);	2795	__set_long_size(__old_sz - __n_del + __n_add);
2779	}	2796	}
2780		2797
...	@@ -2786,24 +2803,23 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string<_CharT, _Traits, _Al	...	@@ -2786,24 +2803,23 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE basic_string<_CharT, _Traits, _Al
2786	basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(const value_type* __s, size_type __n) {	2803	basic_string<_CharT, _Traits, _Allocator>::__assign_no_alias(const value_type* __s, size_type __n) {
2787	const auto __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();	2804	const auto __cap = __is_short ? static_cast<size_type>(__min_cap) : __get_long_cap();
2788	const auto __size = __is_short ? __get_short_size() : __get_long_size();	2805	const auto __size = __is_short ? __get_short_size() : __get_long_size();
2789	if (__n < __cap) {	2806	if (__n >= __cap) {
2790	if (__n > __size)
2791	__annotate_increase(__n - __size);
2792	pointer __p;
2793	if (__is_short) {
2794	__p = __get_short_pointer();
2795	__set_short_size(__n);
2796	} else {
2797	__p = __get_long_pointer();
2798	__set_long_size(__n);
2799	}
2800	traits_type::copy(std::__to_address(__p), __s, __n);
2801	traits_type::assign(__p[__n], value_type());
2802	if (__size > __n)
2803	__annotate_shrink(__size);
2804	} else {
2805	__grow_by_and_replace(__cap - 1, __n - __cap + 1, __size, 0, __size, __n, __s);	2807	__grow_by_and_replace(__cap - 1, __n - __cap + 1, __size, 0, __size, __n, __s);
		2808	return *this;
2806	}	2809	}
		2810
		2811	__annotate_delete();
		2812	auto __guard = std::__make_scope_guard(__annotate_new_size(*this));
		2813	pointer __p;
		2814	if (__is_short) {
		2815	__p = __get_short_pointer();
		2816	__set_short_size(__n);
		2817	} else {
		2818	__p = __get_long_pointer();
		2819	__set_long_size(__n);
		2820	}
		2821	traits_type::copy(std::__to_address(__p), __s, __n);
		2822	traits_type::assign(__p[__n], value_type());
2807	return *this;	2823	return *this;
2808	}	2824	}
2809		2825
...	@@ -2910,7 +2926,7 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr	...	@@ -2910,7 +2926,7 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr
2910	{	2926	{
2911	__annotate_delete();	2927	__annotate_delete();
2912	if (__is_long()) {	2928	if (__is_long()) {
2913	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());	2929	__reset_internal_buffer();
2914	# if _LIBCPP_STD_VER <= 14	2930	# if _LIBCPP_STD_VER <= 14
2915	if (!is_nothrow_move_assignable<allocator_type>::value) {	2931	if (!is_nothrow_move_assignable<allocator_type>::value) {
2916	__set_short_size(0);	2932	__set_short_size(0);
...	@@ -2961,7 +2977,7 @@ template <class _Iterator, class _Sentinel>	...	@@ -2961,7 +2977,7 @@ template <class _Iterator, class _Sentinel>
2961	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void	2977	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI void
2962	basic_string<_CharT, _Traits, _Allocator>::__assign_trivial(_Iterator __first, _Sentinel __last, size_type __n) {	2978	basic_string<_CharT, _Traits, _Allocator>::__assign_trivial(_Iterator __first, _Sentinel __last, size_type __n) {
2963	_LIBCPP_ASSERT_INTERNAL(	2979	_LIBCPP_ASSERT_INTERNAL(
2964	__string_is_trivial_iterator<_Iterator>::value, "The iterator type given to `__assign_trivial` must be trivial");	2980	__string_is_trivial_iterator_v<_Iterator>, "The iterator type given to `__assign_trivial` must be trivial");
2965		2981
2966	size_type __old_size = size();	2982	size_type __old_size = size();
2967	size_type __cap = capacity();	2983	size_type __cap = capacity();
...	@@ -3017,52 +3033,40 @@ basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_ty	...	@@ -3017,52 +3033,40 @@ basic_string<_CharT, _Traits, _Allocator>::append(const value_type* __s, size_ty
3017	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::append received nullptr");	3033	_LIBCPP_ASSERT_NON_NULL(__n == 0 \|\| __s != nullptr, "string::append received nullptr");
3018	size_type __cap = capacity();	3034	size_type __cap = capacity();
3019	size_type __sz = size();	3035	size_type __sz = size();
3020	if (__cap - __sz >= __n) {	3036	if (__cap - __sz < __n) {
3021	if (__n) {
3022	__annotate_increase(__n);
3023	value_type* __p = std::__to_address(__get_pointer());
3024	traits_type::copy(__p + __sz, __s, __n);
3025	__sz += __n;
3026	__set_size(__sz);
3027	traits_type::assign(__p[__sz], value_type());
3028	}
3029	} else
3030	__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);	3037	__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __sz, 0, __n, __s);
		3038	return *this;
		3039	}
		3040
		3041	if (__n == 0)
		3042	return *this;
		3043
		3044	__annotate_increase(__n);
		3045	value_type* __p = std::__to_address(__get_pointer());
		3046	traits_type::copy(__p + __sz, __s, __n);
		3047	__sz += __n;
		3048	__set_size(__sz);
		3049	traits_type::assign(__p[__sz], value_type());
3031	return *this;	3050	return *this;
3032	}	3051	}
3033		3052
3034	template <class _CharT, class _Traits, class _Allocator>	3053	template <class _CharT, class _Traits, class _Allocator>
3035	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&	3054	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<_CharT, _Traits, _Allocator>&
3036	basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) {	3055	basic_string<_CharT, _Traits, _Allocator>::append(size_type __n, value_type __c) {
3037	if (__n) {	3056	if (__n == 0)
3038	size_type __cap = capacity();	3057	return *this;
3039	size_type __sz = size();
3040	if (__cap - __sz < __n)
3041	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
3042	__annotate_increase(__n);
3043	pointer __p = __get_pointer();
3044	traits_type::assign(std::__to_address(__p) + __sz, __n, __c);
3045	__sz += __n;
3046	__set_size(__sz);
3047	traits_type::assign(__p[__sz], value_type());
3048	}
3049	return *this;
3050	}
3051		3058
3052	template <class _CharT, class _Traits, class _Allocator>	3059	size_type __cap = capacity();
3053	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void	3060	size_type __sz = size();
3054	basic_string<_CharT, _Traits, _Allocator>::__append_default_init(size_type __n) {	3061	if (__cap - __sz < __n)
3055	if (__n) {	3062	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);
3056	size_type __cap = capacity();	3063	__annotate_increase(__n);
3057	size_type __sz = size();	3064	pointer __p = __get_pointer();
3058	if (__cap - __sz < __n)	3065	traits_type::assign(std::__to_address(__p) + __sz, __n, __c);
3059	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __sz, 0);	3066	__sz += __n;
3060	__annotate_increase(__n);	3067	__set_size(__sz);
3061	pointer __p = __get_pointer();	3068	traits_type::assign(__p[__sz], value_type());
3062	__sz += __n;	3069	return *this;
3063	__set_size(__sz);
3064	traits_type::assign(__p[__sz], value_type());
3065	}
3066	}	3070	}
3067		3071
3068	template <class _CharT, class _Traits, class _Allocator>	3072	template <class _CharT, class _Traits, class _Allocator>
...	@@ -3120,23 +3124,27 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_t	...	@@ -3120,23 +3124,27 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, const value_t
3120	if (__pos > __sz)	3124	if (__pos > __sz)
3121	this->__throw_out_of_range();	3125	this->__throw_out_of_range();
3122	size_type __cap = capacity();	3126	size_type __cap = capacity();
3123	if (__cap - __sz >= __n) {	3127
3124	if (__n) {	3128	if (__cap - __sz < __n) {
3125	__annotate_increase(__n);
3126	value_type* __p = std::__to_address(__get_pointer());
3127	size_type __n_move = __sz - __pos;
3128	if (__n_move != 0) {
3129	if (std::__is_pointer_in_range(__p + __pos, __p + __sz, __s))
3130	__s += __n;
3131	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
3132	}
3133	traits_type::move(__p + __pos, __s, __n);
3134	__sz += __n;
3135	__set_size(__sz);
3136	traits_type::assign(__p[__sz], value_type());
3137	}
3138	} else
3139	__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);	3129	__grow_by_and_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n, __s);
		3130	return *this;
		3131	}
		3132
		3133	if (__n == 0)
		3134	return *this;
		3135
		3136	__annotate_increase(__n);
		3137	value_type* __p = std::__to_address(__get_pointer());
		3138	size_type __n_move = __sz - __pos;
		3139	if (__n_move != 0) {
		3140	if (std::__is_pointer_in_range(__p + __pos, __p + __sz, __s))
		3141	__s += __n;
		3142	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
		3143	}
		3144	traits_type::move(__p + __pos, __s, __n);
		3145	__sz += __n;
		3146	__set_size(__sz);
		3147	traits_type::assign(__p[__sz], value_type());
3140	return *this;	3148	return *this;
3141	}	3149	}
3142		3150
...	@@ -3146,24 +3154,26 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n	...	@@ -3146,24 +3154,26 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos, size_type __n
3146	size_type __sz = size();	3154	size_type __sz = size();
3147	if (__pos > __sz)	3155	if (__pos > __sz)
3148	this->__throw_out_of_range();	3156	this->__throw_out_of_range();
3149	if (__n) {	3157
3150	size_type __cap = capacity();	3158	if (__n == 0)
3151	value_type* __p;	3159	return *this;
3152	if (__cap - __sz >= __n) {	3160
3153	__annotate_increase(__n);	3161	size_type __cap = capacity();
3154	__p = std::__to_address(__get_pointer());	3162	value_type* __p;
3155	size_type __n_move = __sz - __pos;	3163	if (__cap - __sz >= __n) {
3156	if (__n_move != 0)	3164	__annotate_increase(__n);
3157	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);	3165	__p = std::__to_address(__get_pointer());
3158	} else {	3166	size_type __n_move = __sz - __pos;
3159	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);	3167	if (__n_move != 0)
3160	__p = std::__to_address(__get_long_pointer());	3168	traits_type::move(__p + __pos + __n, __p + __pos, __n_move);
3161	}	3169	} else {
3162	traits_type::assign(__p + __pos, __n, __c);	3170	__grow_by_without_replace(__cap, __sz + __n - __cap, __sz, __pos, 0, __n);
3163	__sz += __n;	3171	__p = std::__to_address(__get_long_pointer());
3164	__set_size(__sz);
3165	traits_type::assign(__p[__sz], value_type());
3166	}	3172	}
		3173	traits_type::assign(__p + __pos, __n, __c);
		3174	__sz += __n;
		3175	__set_size(__sz);
		3176	traits_type::assign(__p[__sz], value_type());
3167	return *this;	3177	return *this;
3168	}	3178	}
3169		3179
...	@@ -3176,7 +3186,7 @@ basic_string<_CharT, _Traits, _Allocator>::__insert_with_size(	...	@@ -3176,7 +3186,7 @@ basic_string<_CharT, _Traits, _Allocator>::__insert_with_size(
3176	if (__n == 0)	3186	if (__n == 0)
3177	return begin() + __ip;	3187	return begin() + __ip;
3178		3188
3179	if (__string_is_trivial_iterator<_Iterator>::value && !__addr_in_range(*__first)) {	3189	if (__string_is_trivial_iterator_v<_Iterator> && !__addr_in_range(*__first)) {
3180	return __insert_from_safe_copy(__n, __ip, std::move(__first), std::move(__last));	3190	return __insert_from_safe_copy(__n, __ip, std::move(__first), std::move(__last));
3181	} else {	3191	} else {
3182	const basic_string __temp(__init_with_sentinel_tag(), std::move(__first), std::move(__last), __alloc_);	3192	const basic_string __temp(__init_with_sentinel_tag(), std::move(__first), std::move(__last), __alloc_);
...	@@ -3237,38 +3247,38 @@ basic_string<_CharT, _Traits, _Allocator>::replace(	...	@@ -3237,38 +3247,38 @@ basic_string<_CharT, _Traits, _Allocator>::replace(
3237	this->__throw_out_of_range();	3247	this->__throw_out_of_range();
3238	__n1 = std::min(__n1, __sz - __pos);	3248	__n1 = std::min(__n1, __sz - __pos);
3239	size_type __cap = capacity();	3249	size_type __cap = capacity();
3240	if (__cap - __sz + __n1 >= __n2) {	3250	if (__cap - __sz + __n1 < __n2) {
3241	value_type* __p = std::__to_address(__get_pointer());	3251	__grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
3242	if (__n1 != __n2) {	3252	return *this;
3243	if (__n2 > __n1)	3253	}
3244	__annotate_increase(__n2 - __n1);	3254
3245	size_type __n_move = __sz - __pos - __n1;	3255	value_type* __p = std::__to_address(__get_pointer());
3246	if (__n_move != 0) {	3256	if (__n1 != __n2) {
3247	if (__n1 > __n2) {	3257	if (__n2 > __n1)
3248	traits_type::move(__p + __pos, __s, __n2);	3258	__annotate_increase(__n2 - __n1);
3249	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);	3259	size_type __n_move = __sz - __pos - __n1;
3250	return __null_terminate_at(__p, __sz + (__n2 - __n1));	3260	if (__n_move != 0) {
3251	}	3261	if (__n1 > __n2) {
3252	if (std::__is_pointer_in_range(__p + __pos + 1, __p + __sz, __s)) {	3262	traits_type::move(__p + __pos, __s, __n2);
3253	if (__p + __pos + __n1 <= __s)
3254	__s += __n2 - __n1;
3255	else // __p + __pos < __s < __p + __pos + __n1
3256	{
3257	traits_type::move(__p + __pos, __s, __n1);
3258	__pos += __n1;
3259	__s += __n2;
3260	__n2 -= __n1;
3261	__n1 = 0;
3262	}
3263	}
3264	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);	3263	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
		3264	return __null_terminate_at(__p, __sz + (__n2 - __n1));
		3265	}
		3266	if (std::__is_pointer_in_range(__p + __pos + 1, __p + __sz, __s)) {
		3267	if (__p + __pos + __n1 <= __s) {
		3268	__s += __n2 - __n1;
		3269	} else { // __p + __pos < __s < __p + __pos + __n1
		3270	traits_type::move(__p + __pos, __s, __n1);
		3271	__pos += __n1;
		3272	__s += __n2;
		3273	__n2 -= __n1;
		3274	__n1 = 0;
		3275	}
3265	}	3276	}
		3277	traits_type::move(__p + __pos + __n2, __p + __pos + __n1, __n_move);
3266	}	3278	}
3267	traits_type::move(__p + __pos, __s, __n2);	3279	}
3268	return __null_terminate_at(__p, __sz + (__n2 - __n1));	3280	traits_type::move(__p + __pos, __s, __n2);
3269	} else	3281	return __null_terminate_at(__p, __sz + (__n2 - __n1));
3270	__grow_by_and_replace(__cap, __sz - __n1 + __n2 - __cap, __sz, __pos, __n1, __n2, __s);
3271	return *this;
3272	}	3282	}
3273		3283
3274	template <class _CharT, class _Traits, class _Allocator>	3284	template <class _CharT, class _Traits, class _Allocator>
...	@@ -3320,16 +3330,17 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __	...	@@ -3320,16 +3330,17 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
3320	// Does not check __pos against size()	3330	// Does not check __pos against size()
3321	template <class _CharT, class _Traits, class _Allocator>	3331	template <class _CharT, class _Traits, class _Allocator>
3322	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void	3332	_LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_NOINLINE void
3323	basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(size_type __pos, size_type __n) {	3333	basic_string<_CharT, _Traits, _Allocator>::__erase_external_with_move(size_type __pos, size_type __n) _NOEXCEPT {
3324	if (__n) {	3334	if (__n == 0)
3325	size_type __sz = size();	3335	return;
3326	value_type* __p = std::__to_address(__get_pointer());	3336
3327	__n = std::min(__n, __sz - __pos);	3337	size_type __sz = size();
3328	size_type __n_move = __sz - __pos - __n;	3338	value_type* __p = std::__to_address(__get_pointer());
3329	if (__n_move != 0)	3339	__n = std::min(__n, __sz - __pos);
3330	traits_type::move(__p + __pos, __p + __pos + __n, __n_move);	3340	size_type __n_move = __sz - __pos - __n;
3331	__null_terminate_at(__p, __sz - __n);	3341	if (__n_move != 0)
3332	}	3342	traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
		3343	__null_terminate_at(__p, __sz - __n);
3333	}	3344	}
3334		3345
3335	template <class _CharT, class _Traits, class _Allocator>	3346	template <class _CharT, class _Traits, class _Allocator>
...	@@ -3396,16 +3407,6 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::re	...	@@ -3396,16 +3407,6 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::re
3396	__erase_to_end(__n);	3407	__erase_to_end(__n);
3397	}	3408	}
3398		3409
3399	template <class _CharT, class _Traits, class _Allocator>
3400	_LIBCPP_CONSTEXPR_SINCE_CXX20 inline void
3401	basic_string<_CharT, _Traits, _Allocator>::__resize_default_init(size_type __n) {
3402	size_type __sz = size();
3403	if (__n > __sz) {
3404	__append_default_init(__n - __sz);
3405	} else
3406	__erase_to_end(__n);
3407	}
3408
3409	template <class _CharT, class _Traits, class _Allocator>	3410	template <class _CharT, class _Traits, class _Allocator>
3410	_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) {	3411	_LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __requested_capacity) {
3411	if (__requested_capacity > max_size())	3412	if (__requested_capacity > max_size())
...	@@ -3418,31 +3419,23 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::re	...	@@ -3418,31 +3419,23 @@ _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::re
3418	return;	3419	return;
3419		3420
3420	__annotation_guard __g(*this);	3421	__annotation_guard __g(*this);
3421	auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__requested_capacity) + 1);	3422	__long __buffer = __allocate_long_buffer(__alloc_, __requested_capacity);
3422	auto __size = size();	3423	__buffer.__size_ = size();
3423	__begin_lifetime(__allocation.ptr, __allocation.count);	3424	traits_type::copy(std::__to_address(__buffer.__data_), data(), __buffer.__size_ + 1);
3424	traits_type::copy(std::__to_address(__allocation.ptr), data(), __size + 1);	3425	__reset_internal_buffer(__buffer);
3425	if (__is_long())
3426	__alloc_traits::deallocate(__alloc_, __get_long_pointer(), __get_long_cap());
3427	__set_long_cap(__allocation.count);
3428	__set_long_size(__size);
3429	__set_long_pointer(__allocation.ptr);
3430	}	3426	}
3431		3427
3432	template <class _CharT, class _Traits, class _Allocator>	3428	template <class _CharT, class _Traits, class _Allocator>
3433	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT {	3429	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocator>::shrink_to_fit() _NOEXCEPT {
3434	size_type __target_capacity = __recommend(size());	3430	if (!__is_long())
3435	if (__target_capacity == capacity())
3436	return;	3431	return;
3437		3432
3438	_LIBCPP_ASSERT_INTERNAL(__is_long(), "Trying to shrink small string");
3439
3440	// We're a long string and we're shrinking into the small buffer.
3441	const auto __ptr = __get_long_pointer();	3433	const auto __ptr = __get_long_pointer();
3442	const auto __size = __get_long_size();	3434	const auto __size = __get_long_size();
3443	const auto __cap = __get_long_cap();	3435	const auto __cap = __get_long_cap();
3444		3436
3445	if (__fits_in_sso(__target_capacity)) {	3437	// We're a long string and we're shrinking into the small buffer.
		3438	if (__fits_in_sso(__size)) {
3446	__annotation_guard __g(*this);	3439	__annotation_guard __g(*this);
3447	__set_short_size(__size);	3440	__set_short_size(__size);
3448	traits_type::copy(std::__to_address(__get_short_pointer()), std::__to_address(__ptr), __size + 1);	3441	traits_type::copy(std::__to_address(__get_short_pointer()), std::__to_address(__ptr), __size + 1);
...	@@ -3450,25 +3443,25 @@ inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocat	...	@@ -3450,25 +3443,25 @@ inline _LIBCPP_CONSTEXPR_SINCE_CXX20 void basic_string<_CharT, _Traits, _Allocat
3450	return;	3443	return;
3451	}	3444	}
3452		3445
		3446	if (__align_allocation_size(__size) == __cap)
		3447	return;
		3448
3453	# if _LIBCPP_HAS_EXCEPTIONS	3449	# if _LIBCPP_HAS_EXCEPTIONS
3454	try {	3450	try {
3455	# endif // _LIBCPP_HAS_EXCEPTIONS	3451	# endif // _LIBCPP_HAS_EXCEPTIONS
3456	__annotation_guard __g(*this);	3452	__annotation_guard __g(*this);
3457	auto __allocation = std::__allocate_at_least(__alloc_, __target_capacity + 1);	3453	__long __buffer = __allocate_long_buffer(__alloc_, __size);
3458		3454
3459	// The Standard mandates shrink_to_fit() does not increase the capacity.	3455	// The Standard mandates shrink_to_fit() does not increase the capacity.
3460	// With equal capacity keep the existing buffer. This avoids extra work	3456	// With equal capacity keep the existing buffer. This avoids extra work
3461	// due to swapping the elements.	3457	// due to swapping the elements.
3462	if (__allocation.count - 1 >= capacity()) {	3458	if (__buffer.__cap_ * __endian_factor - 1 >= capacity()) {
3463	__alloc_traits::deallocate(__alloc_, __allocation.ptr, __allocation.count);	3459	__alloc_traits::deallocate(__alloc_, __buffer.__data_, __buffer.__cap_ * __endian_factor);
3464	return;	3460	return;
3465	}	3461	}
3466		3462
3467	__begin_lifetime(__allocation.ptr, __allocation.count);	3463	traits_type::copy(std::__to_address(__buffer.__data_), std::__to_address(__get_long_pointer()), __size + 1);
3468	traits_type::copy(std::__to_address(__allocation.ptr), std::__to_address(__ptr), __size + 1);	3464	__reset_internal_buffer(__buffer);
3469	__alloc_traits::deallocate(__alloc_, __ptr, __cap);
3470	__set_long_cap(__allocation.count);
3471	__set_long_pointer(__allocation.ptr);
3472	# if _LIBCPP_HAS_EXCEPTIONS	3465	# if _LIBCPP_HAS_EXCEPTIONS
3473	} catch (...) {	3466	} catch (...) {
3474	return;	3467	return;
...	@@ -3574,7 +3567,8 @@ operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,	...	@@ -3574,7 +3567,8 @@ operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
3574		3567
3575	template <class _CharT, class _Traits, class _Allocator>	3568	template <class _CharT, class _Traits, class _Allocator>
3576	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool	3569	inline _LIBCPP_CONSTEXPR_SINCE_CXX20 _LIBCPP_HIDE_FROM_ABI bool
3577	operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs, const _CharT* __rhs) _NOEXCEPT {	3570	operator==(const basic_string<_CharT, _Traits, _Allocator>& __lhs,
		3571	const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __rhs) _NOEXCEPT {
3578	_LIBCPP_ASSERT_NON_NULL(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");	3572	_LIBCPP_ASSERT_NON_NULL(__rhs != nullptr, "operator==(basic_string, char*): received nullptr");
3579		3573
3580	using _String = basic_string<_CharT, _Traits, _Allocator>;	3574	using _String = basic_string<_CharT, _Traits, _Allocator>;
...	@@ -3858,46 +3852,52 @@ swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Tra	...	@@ -3858,46 +3852,52 @@ swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Tra
3858	__lhs.swap(__rhs);	3852	__lhs.swap(__rhs);
3859	}	3853	}
3860		3854
3861	_LIBCPP_EXPORTED_FROM_ABI int stoi(const string& __str, size_t* __idx = nullptr, int __base = 10);	3855	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI int stoi(const string& __str, size_t* __idx = nullptr, int __base = 10);
3862	_LIBCPP_EXPORTED_FROM_ABI long stol(const string& __str, size_t* __idx = nullptr, int __base = 10);	3856	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI unsigned long
3863	_LIBCPP_EXPORTED_FROM_ABI unsigned long stoul(const string& __str, size_t* __idx = nullptr, int __base = 10);	3857	stoul(const string& __str, size_t* __idx = nullptr, int __base = 10);
3864	_LIBCPP_EXPORTED_FROM_ABI long long stoll(const string& __str, size_t* __idx = nullptr, int __base = 10);	3858	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI long stol(const string& __str, size_t* __idx = nullptr, int __base = 10);
3865	_LIBCPP_EXPORTED_FROM_ABI unsigned long long stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);	3859	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI long long
3866		3860	stoll(const string& __str, size_t* __idx = nullptr, int __base = 10);
3867	_LIBCPP_EXPORTED_FROM_ABI float stof(const string& __str, size_t* __idx = nullptr);	3861	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI unsigned long long
3868	_LIBCPP_EXPORTED_FROM_ABI double stod(const string& __str, size_t* __idx = nullptr);	3862	stoull(const string& __str, size_t* __idx = nullptr, int __base = 10);
3869	_LIBCPP_EXPORTED_FROM_ABI long double stold(const string& __str, size_t* __idx = nullptr);	3863
3870		3864	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI float stof(const string& __str, size_t* __idx = nullptr);
3871	_LIBCPP_EXPORTED_FROM_ABI string to_string(int __val);	3865	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI double stod(const string& __str, size_t* __idx = nullptr);
3872	_LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned __val);	3866	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI long double stold(const string& __str, size_t* __idx = nullptr);
3873	_LIBCPP_EXPORTED_FROM_ABI string to_string(long __val);	3867
3874	_LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned long __val);	3868	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(int __val);
3875	_LIBCPP_EXPORTED_FROM_ABI string to_string(long long __val);	3869	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned __val);
3876	_LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned long long __val);	3870	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(long __val);
3877	_LIBCPP_EXPORTED_FROM_ABI string to_string(float __val);	3871	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned long __val);
3878	_LIBCPP_EXPORTED_FROM_ABI string to_string(double __val);	3872	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(long long __val);
3879	_LIBCPP_EXPORTED_FROM_ABI string to_string(long double __val);	3873	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(unsigned long long __val);
		3874	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(float __val);
		3875	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(double __val);
		3876	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI string to_string(long double __val);
3880		3877
3881	# if _LIBCPP_HAS_WIDE_CHARACTERS	3878	# if _LIBCPP_HAS_WIDE_CHARACTERS
3882	_LIBCPP_EXPORTED_FROM_ABI int stoi(const wstring& __str, size_t* __idx = nullptr, int __base = 10);	3879	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI int stoi(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
3883	_LIBCPP_EXPORTED_FROM_ABI long stol(const wstring& __str, size_t* __idx = nullptr, int __base = 10);	3880	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI long stol(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
3884	_LIBCPP_EXPORTED_FROM_ABI unsigned long stoul(const wstring& __str, size_t* __idx = nullptr, int __base = 10);	3881	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI unsigned long
3885	_LIBCPP_EXPORTED_FROM_ABI long long stoll(const wstring& __str, size_t* __idx = nullptr, int __base = 10);	3882	stoul(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
3886	_LIBCPP_EXPORTED_FROM_ABI unsigned long long stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10);	3883	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI long long
3887		3884	stoll(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
3888	_LIBCPP_EXPORTED_FROM_ABI float stof(const wstring& __str, size_t* __idx = nullptr);	3885	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI unsigned long long
3889	_LIBCPP_EXPORTED_FROM_ABI double stod(const wstring& __str, size_t* __idx = nullptr);	3886	stoull(const wstring& __str, size_t* __idx = nullptr, int __base = 10);
3890	_LIBCPP_EXPORTED_FROM_ABI long double stold(const wstring& __str, size_t* __idx = nullptr);	3887
3891		3888	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI float stof(const wstring& __str, size_t* __idx = nullptr);
3892	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(int __val);	3889	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI double stod(const wstring& __str, size_t* __idx = nullptr);
3893	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned __val);	3890	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI long double stold(const wstring& __str, size_t* __idx = nullptr);
3894	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long __val);	3891
3895	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned long __val);	3892	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(int __val);
3896	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long long __val);	3893	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned __val);
3897	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned long long __val);	3894	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long __val);
3898	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(float __val);	3895	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned long __val);
3899	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(double __val);	3896	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long long __val);
3900	_LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long double __val);	3897	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(unsigned long long __val);
		3898	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(float __val);
		3899	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(double __val);
		3900	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI wstring to_wstring(long double __val);
3901	# endif // _LIBCPP_HAS_WIDE_CHARACTERS	3901	# endif // _LIBCPP_HAS_WIDE_CHARACTERS
3902		3902
3903	template <class _CharT, class _Traits, class _Allocator>	3903	template <class _CharT, class _Traits, class _Allocator>
...	@@ -3906,7 +3906,7 @@ _LIBCPP_TEMPLATE_DATA_VIS const typename basic_string<_CharT, _Traits, _Allocato	...	@@ -3906,7 +3906,7 @@ _LIBCPP_TEMPLATE_DATA_VIS const typename basic_string<_CharT, _Traits, _Allocato
3906		3906
3907	template <class _CharT, class _Allocator>	3907	template <class _CharT, class _Allocator>
3908	struct __string_hash : public __unary_function<basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t> {	3908	struct __string_hash : public __unary_function<basic_string<_CharT, char_traits<_CharT>, _Allocator>, size_t> {
3909	_LIBCPP_HIDE_FROM_ABI size_t	3909	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t
3910	operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT {	3910	operator()(const basic_string<_CharT, char_traits<_CharT>, _Allocator>& __val) const _NOEXCEPT {
3911	return std::__do_string_hash(__val.data(), __val.data() + __val.size());	3911	return std::__do_string_hash(__val.data(), __val.data() + __val.size());
3912	}	3912	}
...	@@ -3977,30 +3977,31 @@ erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred) {	...	@@ -3977,30 +3977,31 @@ erase_if(basic_string<_CharT, _Traits, _Allocator>& __str, _Predicate __pred) {
3977	// Literal suffixes for basic_string [basic.string.literals]	3977	// Literal suffixes for basic_string [basic.string.literals]
3978	inline namespace literals {	3978	inline namespace literals {
3979	inline namespace string_literals {	3979	inline namespace string_literals {
3980	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char>	3980	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char>
3981	operator""s(const char* __str, size_t __len) {	3981	operator""s(const char* __str, size_t __len) {
3982	return basic_string<char>(__str, __len);	3982	return basic_string<char>(__str, __len);
3983	}	3983	}
3984		3984
3985	# if _LIBCPP_HAS_WIDE_CHARACTERS	3985	# if _LIBCPP_HAS_WIDE_CHARACTERS
3986	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<wchar_t>	3986	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
3987	operator""s(const wchar_t* __str, size_t __len) {	3987	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<wchar_t> operator""s(const wchar_t* __str, size_t __len) {
3988	return basic_string<wchar_t>(__str, __len);	3988	return basic_string<wchar_t>(__str, __len);
3989	}	3989	}
3990	# endif	3990	# endif
3991		3991
3992	# if _LIBCPP_HAS_CHAR8_T	3992	# if _LIBCPP_HAS_CHAR8_T
3993	inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string<char8_t> operator""s(const char8_t* __str, size_t __len) {	3993	[[__nodiscard__]] inline
		3994	_LIBCPP_HIDE_FROM_ABI constexpr basic_string<char8_t> operator""s(const char8_t* __str, size_t __len) {
3994	return basic_string<char8_t>(__str, __len);	3995	return basic_string<char8_t>(__str, __len);
3995	}	3996	}
3996	# endif	3997	# endif
3997		3998
3998	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char16_t>	3999	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
3999	operator""s(const char16_t* __str, size_t __len) {	4000	_LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char16_t> operator""s(const char16_t* __str, size_t __len) {
4000	return basic_string<char16_t>(__str, __len);	4001	return basic_string<char16_t>(__str, __len);
4001	}	4002	}
4002		4003
4003	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char32_t>	4004	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 basic_string<char32_t>
4004	operator""s(const char32_t* __str, size_t __len) {	4005	operator""s(const char32_t* __str, size_t __len) {
4005	return basic_string<char32_t>(__str, __len);	4006	return basic_string<char32_t>(__str, __len);
4006	}	4007	}

lib/libcxx/include/string_view+113-89

 @@ -130,6 +130,8 @@ namespace std {
       size_type copy(charT* s, size_type n, size_type pos = 0) const;  // constexpr in C++20
       constexpr basic_string_view substr(size_type pos = 0, size_type n = npos) const;
+      constexpr basic_string_view subview(size_type pos = 0,
+                                          size_type n = npos) const;      // freestanding-deleted, since C++26
       constexpr int compare(basic_string_view s) const noexcept;
       constexpr int compare(size_type pos1, size_type n1, basic_string_view s) const;
       constexpr int compare(size_type pos1, size_type n1,
 @@ -318,9 +320,9 @@ public:
   _LIBCPP_HIDE_FROM_ABI basic_string_view& operator=(const basic_string_view&) _NOEXCEPT = default;
   _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s, size_type __len) _NOEXCEPT
-      : __data_(__s),
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__len != 0 && __s == nullptr, " if len is not zero")
-        __size_(__len) {
+      : __data_(__s), __size_(__len) {
-#  if _LIBCPP_STD_VER >= 14
+#  if !defined(_LIBCPP_CXX03_LANG) && (!defined(_LIBCPP_COMPILER_GCC) || _LIBCPP_STD_VER >= 14)
     // Allocations must fit in `ptrdiff_t` for pointer arithmetic to work. If `__len` exceeds it, the input
     // range could not have been valid. Most likely the caller underflowed some arithmetic and inadvertently
     // passed in a negative length.
 @@ -352,7 +354,7 @@ public:
       : __data_(ranges::data(__r)), __size_(ranges::size(__r)) {}
 #  endif // _LIBCPP_STD_VER >= 23
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* __s)
+  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s)
       : __data_(__s), __size_(std::__char_traits_length_checked<_Traits>(__s)) {}
 #  if _LIBCPP_STD_VER >= 23
 @@ -360,11 +362,11 @@ public:
 #  endif
   // [string.view.iterators], iterators
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return cbegin(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return cbegin(); }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return cend(); }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return cend(); }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT {
 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
     return std::__make_bounded_iter(data(), data(), data() + size());
 #  else
 @@ -372,7 +374,7 @@ public:
 #  endif
   }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT {
 #  ifdef _LIBCPP_ABI_BOUNDED_ITERATORS
     return std::__make_bounded_iter(data() + size(), data(), data() + size());
 #  else
 @@ -380,51 +382,54 @@ public:
 #  endif
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator
+  rbegin() const _NOEXCEPT {
     return const_reverse_iterator(cend());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator rend() const _NOEXCEPT {
     return const_reverse_iterator(cbegin());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crbegin() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator
+  crbegin() const _NOEXCEPT {
     return const_reverse_iterator(cend());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX17 _LIBCPP_HIDE_FROM_ABI const_reverse_iterator crend() const _NOEXCEPT {
     return const_reverse_iterator(cbegin());
   }
   // [string.view.capacity], capacity
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __size_; }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type length() const _NOEXCEPT { return __size_; }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type length() const _NOEXCEPT { return __size_; }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT {
     return numeric_limits<size_type>::max() / sizeof(value_type);
   }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR bool empty() const _NOEXCEPT { return __size_ == 0; }
   // [string.view.access], element access
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference operator[](size_type __pos) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference
+  operator[](size_type __pos) const _NOEXCEPT {
     return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__pos < size(), "string_view[] index out of bounds"), __data_[__pos];
   }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __pos) const {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference at(size_type __pos) const {
     return __pos >= size() ? (__throw_out_of_range("string_view::at"), __data_[0]) : __data_[__pos];
   }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference front() const _NOEXCEPT {
     return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::front(): string is empty"), __data_[0];
   }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_reference back() const _NOEXCEPT {
     return _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(!empty(), "string_view::back(): string is empty"), __data_[__size_ - 1];
   }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_pointer data() const _NOEXCEPT { return __data_; }
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI const_pointer data() const _NOEXCEPT { return __data_; }
   // [string.view.modifiers], modifiers:
   _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI void remove_prefix(size_type __n) _NOEXCEPT {
 @@ -457,15 +462,23 @@ public:
     return __rlen;
   }
-  _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view substr(size_type __pos = 0, size_type __n = npos) const {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR _LIBCPP_HIDE_FROM_ABI basic_string_view
+  substr(size_type __pos = 0, size_type __n = npos) const {
     // Use the `__assume_valid` form of the constructor to avoid an unnecessary check. Any substring of a view is a
     // valid view. In particular, `size()` is known to be smaller than `numeric_limits<difference_type>::max()`, so the
-    // new size is also smaller. See also https://github.com/llvm/llvm-project/issues/91634.
+    // new size is also smaller. See also https://llvm.org/PR91634.
     return __pos > size() ? (__throw_out_of_range("string_view::substr"), basic_string_view())
                           : basic_string_view(__assume_valid(), data() + __pos, std::min(__n, size() - __pos));
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 int compare(basic_string_view __sv) const _NOEXCEPT {
+#  if _LIBCPP_STD_VER >= 26
+  [[nodiscard]]
+  _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view subview(size_type __pos = 0, size_type __n = npos) const {
+    return substr(__pos, __n);
+  }
+#  endif
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 int compare(basic_string_view __sv) const _NOEXCEPT {
     size_type __rlen = std::min(size(), __sv.size());
     int __retval     = _Traits::compare(data(), __sv.data(), __rlen);
     if (__retval == 0) // first __rlen chars matched
 @@ -473,217 +486,226 @@ public:
     return __retval;
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
   compare(size_type __pos1, size_type __n1, basic_string_view __sv) const {
     return substr(__pos1, __n1).compare(__sv);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
   compare(size_type __pos1, size_type __n1, basic_string_view __sv, size_type __pos2, size_type __n2) const {
     return substr(__pos1, __n1).compare(__sv.substr(__pos2, __n2));
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int compare(const _CharT* __s) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  compare(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s) const _NOEXCEPT {
     return compare(basic_string_view(__s));
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
-  compare(size_type __pos1, size_type __n1, const _CharT* __s) const {
+  compare(size_type __pos1, size_type __n1, const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s) const {
     return substr(__pos1, __n1).compare(basic_string_view(__s));
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI int
-  compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const {
+  compare(size_type __pos1, size_type __n1, const _CharT* __s, size_type __n2) const
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n2 != 0 && __s == nullptr, " if n2 is not zero") {
     return substr(__pos1, __n1).compare(basic_string_view(__s, __n2));
   }
   // find
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
-    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
     return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type find(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  find(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
     return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  find(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
     _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find(): received nullptr");
     return std::__str_find<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
+  find(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {
     _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find(): received nullptr");
     return std::__str_find<value_type, size_type, traits_type, npos>(
         data(), size(), __s, __pos, traits_type::length(__s));
   }
   // rfind
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   rfind(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
-    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find(): received nullptr");
     return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s.data(), __pos, __s.size());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   rfind(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
     return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  rfind(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
     _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::rfind(): received nullptr");
     return std::__str_rfind<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  rfind(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
+  rfind(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {
     _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::rfind(): received nullptr");
     return std::__str_rfind<value_type, size_type, traits_type, npos>(
         data(), size(), __s, __pos, traits_type::length(__s));
   }
   // find_first_of
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_first_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
-    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_first_of(): received nullptr");
     return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s.data(), __pos, __s.size());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_first_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
     return find(__c, __pos);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  find_first_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
     _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_of(): received nullptr");
     return std::__str_find_first_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_first_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
+  find_first_of(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {
     _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_of(): received nullptr");
     return std::__str_find_first_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s, __pos, traits_type::length(__s));
   }
   // find_last_of
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_last_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
-    _LIBCPP_ASSERT_NON_NULL(__s.size() == 0 || __s.data() != nullptr, "string_view::find_last_of(): received nullptr");
     return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s.data(), __pos, __s.size());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_last_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
     return rfind(__c, __pos);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  find_last_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
     _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_of(): received nullptr");
     return std::__str_find_last_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_last_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
+  find_last_of(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {
     _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_of(): received nullptr");
     return std::__str_find_last_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s, __pos, traits_type::length(__s));
   }
   // find_first_not_of
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_first_not_of(basic_string_view __s, size_type __pos = 0) const _NOEXCEPT {
-    _LIBCPP_ASSERT_NON_NULL(
-        __s.size() == 0 || __s.data() != nullptr, "string_view::find_first_not_of(): received nullptr");
     return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s.data(), __pos, __s.size());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_first_not_of(_CharT __c, size_type __pos = 0) const _NOEXCEPT {
     return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
     _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_first_not_of(): received nullptr");
     return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_first_not_of(const _CharT* __s, size_type __pos = 0) const _NOEXCEPT {
+  find_first_not_of(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = 0) const _NOEXCEPT {
     _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_first_not_of(): received nullptr");
     return std::__str_find_first_not_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s, __pos, traits_type::length(__s));
   }
   // find_last_not_of
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_last_not_of(basic_string_view __s, size_type __pos = npos) const _NOEXCEPT {
-    _LIBCPP_ASSERT_NON_NULL(
-        __s.size() == 0 || __s.data() != nullptr, "string_view::find_last_not_of(): received nullptr");
     return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s.data(), __pos, __s.size());
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
   find_last_not_of(_CharT __c, size_type __pos = npos) const _NOEXCEPT {
     return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __c, __pos);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT {
+  find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const _NOEXCEPT
+      _LIBCPP_DIAGNOSE_NULLPTR_IF(__n != 0 && __s == nullptr, " if n is not zero") {
     _LIBCPP_ASSERT_NON_NULL(__n == 0 || __s != nullptr, "string_view::find_last_not_of(): received nullptr");
     return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(data(), size(), __s, __pos, __n);
   }
-  _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
+  [[__nodiscard__]] _LIBCPP_CONSTEXPR_SINCE_CXX14 _LIBCPP_HIDE_FROM_ABI size_type
-  find_last_not_of(const _CharT* __s, size_type __pos = npos) const _NOEXCEPT {
+  find_last_not_of(const _CharT* _LIBCPP_DIAGNOSE_NULLPTR __s, size_type __pos = npos) const _NOEXCEPT {
     _LIBCPP_ASSERT_NON_NULL(__s != nullptr, "string_view::find_last_not_of(): received nullptr");
     return std::__str_find_last_not_of<value_type, size_type, traits_type, npos>(
         data(), size(), __s, __pos, traits_type::length(__s));
   }
 #  if _LIBCPP_STD_VER >= 20
-  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(basic_string_view __s) const noexcept {
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(basic_string_view __s) const noexcept {
     return size() >= __s.size() && compare(0, __s.size(), __s) == 0;
   }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(value_type __c) const noexcept {
     return !empty() && _Traits::eq(front(), __c);
   }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool starts_with(const value_type* __s) const noexcept {
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool
+  starts_with(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const noexcept {
     return starts_with(basic_string_view(__s));
   }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(basic_string_view __s) const noexcept {
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(basic_string_view __s) const noexcept {
     return size() >= __s.size() && compare(size() - __s.size(), npos, __s) == 0;
   }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(value_type __c) const noexcept {
     return !empty() && _Traits::eq(back(), __c);
   }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool ends_with(const value_type* __s) const noexcept {
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool
+  ends_with(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const noexcept {
     return ends_with(basic_string_view(__s));
   }
 #  endif
 #  if _LIBCPP_STD_VER >= 23
-  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(basic_string_view __sv) const noexcept { return find(__sv) != npos; }
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool contains(basic_string_view __sv) const noexcept {
+    return find(__sv) != npos;
+  }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept { return find(__c) != npos; }
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool contains(value_type __c) const noexcept {
+    return find(__c) != npos;
+  }
-  constexpr _LIBCPP_HIDE_FROM_ABI bool contains(const value_type* __s) const { return find(__s) != npos; }
+  [[nodiscard]] constexpr _LIBCPP_HIDE_FROM_ABI bool contains(const value_type* _LIBCPP_DIAGNOSE_NULLPTR __s) const {
+    return find(__s) != npos;
+  }
 #  endif
 private:
 @@ -886,7 +908,8 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, basic_string_view<_CharT, _Trai
 // [string.view.hash]
 template <class _CharT>
 struct __string_view_hash : public __unary_function<basic_string_view<_CharT, char_traits<_CharT> >, size_t> {
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t
+  operator()(const basic_string_view<_CharT, char_traits<_CharT> > __val) const _NOEXCEPT {
     return std::__do_string_hash(__val.data(), __val.data() + __val.size());
   }
 };
 @@ -913,30 +936,31 @@ struct hash<basic_string_view<wchar_t, char_traits<wchar_t> > > : __string_view_
 #  if _LIBCPP_STD_VER >= 14
 inline namespace literals {
 inline namespace string_view_literals {
-inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char> operator""sv(const char* __str, size_t __len) noexcept {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char>
+operator""sv(const char* __str, size_t __len) noexcept {
   return basic_string_view<char>(__str, __len);
 }
 #    if _LIBCPP_HAS_WIDE_CHARACTERS
-inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<wchar_t>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<wchar_t>
 operator""sv(const wchar_t* __str, size_t __len) noexcept {
   return basic_string_view<wchar_t>(__str, __len);
 }
 #    endif
 #    if _LIBCPP_HAS_CHAR8_T
-inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char8_t>
+[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char8_t>
 operator""sv(const char8_t* __str, size_t __len) noexcept {
   return basic_string_view<char8_t>(__str, __len);
 }
 #    endif
-inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char16_t>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char16_t>
 operator""sv(const char16_t* __str, size_t __len) noexcept {
   return basic_string_view<char16_t>(__str, __len);
 }
-inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char32_t>
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr basic_string_view<char32_t>
 operator""sv(const char32_t* __str, size_t __len) noexcept {
   return basic_string_view<char32_t>(__str, __len);
 }

lib/libcxx/include/strstream+10-10

...	@@ -179,8 +179,8 @@ public:	...	@@ -179,8 +179,8 @@ public:
179	void swap(strstreambuf& __rhs);	179	void swap(strstreambuf& __rhs);
180		180
181	void freeze(bool __freezefl = true);	181	void freeze(bool __freezefl = true);
182	char* str();	182	[[__nodiscard__]] char* str();
183	int pcount() const;	183	[[__nodiscard__]] int pcount() const;
184		184
185	protected:	185	protected:
186	int_type overflow(int_type __c = EOF) override;	186	int_type overflow(int_type __c = EOF) override;
...	@@ -264,8 +264,8 @@ public:	...	@@ -264,8 +264,8 @@ public:
264	__sb_.swap(__rhs.__sb_);	264	__sb_.swap(__rhs.__sb_);
265	}	265	}
266		266
267	_LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }	267	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
268	_LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }	268	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
269		269
270	private:	270	private:
271	strstreambuf __sb_;	271	strstreambuf __sb_;
...	@@ -297,10 +297,10 @@ public:	...	@@ -297,10 +297,10 @@ public:
297	__sb_.swap(__rhs.__sb_);	297	__sb_.swap(__rhs.__sb_);
298	}	298	}
299		299
300	_LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }	300	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
301	_LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }	301	_LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
302	_LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }	302	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
303	_LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }	303	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
304		304
305	private:	305	private:
306	strstreambuf __sb_; // exposition only	306	strstreambuf __sb_; // exposition only
...	@@ -340,10 +340,10 @@ public:	...	@@ -340,10 +340,10 @@ public:
340	}	340	}
341		341
342	// Members:	342	// Members:
343	_LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }	343	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI strstreambuf* rdbuf() const { return const_cast<strstreambuf*>(&__sb_); }
344	_LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }	344	_LIBCPP_HIDE_FROM_ABI void freeze(bool __freezefl = true) { __sb_.freeze(__freezefl); }
345	_LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }	345	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI int pcount() const { return __sb_.pcount(); }
346	_LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }	346	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char* str() { return __sb_.str(); }
347		347
348	private:	348	private:
349	strstreambuf __sb_; // exposition only	349	strstreambuf __sb_; // exposition only

lib/libcxx/include/syncstream+4-4

...	@@ -317,9 +317,9 @@ public:	...	@@ -317,9 +317,9 @@ public:
317		317
318	_LIBCPP_HIDE_FROM_ABI bool emit() { return emit(false); }	318	_LIBCPP_HIDE_FROM_ABI bool emit() { return emit(false); }
319		319
320	_LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __wrapped_; }	320	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __wrapped_; }
321		321
322	_LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }	322	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const noexcept { return __str_.get_allocator(); }
323		323
324	_LIBCPP_HIDE_FROM_ABI void set_emit_on_sync(bool __b) noexcept { __emit_on_sync_ = __b; }	324	_LIBCPP_HIDE_FROM_ABI void set_emit_on_sync(bool __b) noexcept { __emit_on_sync_ = __b; }
325		325
...	@@ -496,9 +496,9 @@ public:	...	@@ -496,9 +496,9 @@ public:
496	}	496	}
497	}	497	}
498		498
499	_LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __sb_.get_wrapped(); }	499	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI streambuf_type* get_wrapped() const noexcept { return __sb_.get_wrapped(); }
500		500
501	_LIBCPP_HIDE_FROM_ABI syncbuf_type* rdbuf() const noexcept {	501	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI syncbuf_type* rdbuf() const noexcept {
502	return const_cast<syncbuf_type*>(std::addressof(__sb_));	502	return const_cast<syncbuf_type*>(std::addressof(__sb_));
503	}	503	}
504		504

lib/libcxx/include/tgmath.h+12-12

...	@@ -18,22 +18,22 @@	...	@@ -18,22 +18,22 @@
18	*/	18	*/
19		19
20	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	20	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
21	# include <__cxx03/tgmath.h>	21	# include <__cxx03/__config>
22	#else	22	#else
23	# include <__config>	23	# include <__config>
		24	#endif
24		25
25	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	26	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
26	# pragma GCC system_header	27	# pragma GCC system_header
27	# endif	28	#endif
28		29
29	# ifdef __cplusplus	30	#ifdef __cplusplus
30	# include <cmath>	31	# include <cmath>
31	# include <complex>	32	# include <complex>
32	# else	33	#else
33	# if __has_include_next(<tgmath.h>)	34	# if __has_include_next(<tgmath.h>)
34	# include_next <tgmath.h>	35	# include_next <tgmath.h>
35	# endif
36	# endif	36	# endif
37	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	37	#endif
38		38
39	#endif // _LIBCPP_TGMATH_H	39	#endif // _LIBCPP_TGMATH_H

lib/libcxx/include/tuple+242-212

...	@@ -106,6 +106,11 @@ public:	...	@@ -106,6 +106,11 @@ public:
106		106
107	void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); // constexpr in C++20	107	void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...)); // constexpr in C++20
108	constexpr void swap(const tuple&) const noexcept(see-below); // C++23	108	constexpr void swap(const tuple&) const noexcept(see-below); // C++23
		109
		110	template<tuple-like UTuple>
		111	friend constexpr bool operator==(const tuple& t, const UTuple& u); // C++23
		112	template<tuple-like UTuple>
		113	friend constexpr auto operator<=>(const tuple& t, const UTuple& u); // C++23
109	};	114	};
110		115
111		116
...	@@ -220,19 +225,16 @@ template <class... Types>	...	@@ -220,19 +225,16 @@ template <class... Types>
220	# include <__config>	225	# include <__config>
221	# include <__cstddef/size_t.h>	226	# include <__cstddef/size_t.h>
222	# include <__fwd/array.h>	227	# include <__fwd/array.h>
		228	# include <__fwd/get.h>
223	# include <__fwd/pair.h>	229	# include <__fwd/pair.h>
224	# include <__fwd/tuple.h>	230	# include <__fwd/tuple.h>
225	# include <__memory/allocator_arg_t.h>	231	# include <__memory/allocator_arg_t.h>
226	# include <__memory/uses_allocator.h>	232	# include <__memory/uses_allocator.h>
227	# include <__tuple/find_index.h>	233	# include <__tuple/find_index.h>
228	# include <__tuple/ignore.h>	234	# include <__tuple/ignore.h>
229	# include <__tuple/make_tuple_types.h>
230	# include <__tuple/sfinae_helpers.h>
231	# include <__tuple/tuple_element.h>	235	# include <__tuple/tuple_element.h>
232	# include <__tuple/tuple_indices.h>	236	# include <__tuple/tuple_like.h>
233	# include <__tuple/tuple_like_ext.h>
234	# include <__tuple/tuple_size.h>	237	# include <__tuple/tuple_size.h>
235	# include <__tuple/tuple_types.h>
236	# include <__type_traits/common_reference.h>	238	# include <__type_traits/common_reference.h>
237	# include <__type_traits/common_type.h>	239	# include <__type_traits/common_type.h>
238	# include <__type_traits/conditional.h>	240	# include <__type_traits/conditional.h>
...	@@ -241,7 +243,6 @@ template <class... Types>	...	@@ -241,7 +243,6 @@ template <class... Types>
241	# include <__type_traits/disjunction.h>	243	# include <__type_traits/disjunction.h>
242	# include <__type_traits/enable_if.h>	244	# include <__type_traits/enable_if.h>
243	# include <__type_traits/invoke.h>	245	# include <__type_traits/invoke.h>
244	# include <__type_traits/is_arithmetic.h>
245	# include <__type_traits/is_assignable.h>	246	# include <__type_traits/is_assignable.h>
246	# include <__type_traits/is_constructible.h>	247	# include <__type_traits/is_constructible.h>
247	# include <__type_traits/is_convertible.h>	248	# include <__type_traits/is_convertible.h>
...	@@ -251,7 +252,6 @@ template <class... Types>	...	@@ -251,7 +252,6 @@ template <class... Types>
251	# include <__type_traits/is_nothrow_assignable.h>	252	# include <__type_traits/is_nothrow_assignable.h>
252	# include <__type_traits/is_nothrow_constructible.h>	253	# include <__type_traits/is_nothrow_constructible.h>
253	# include <__type_traits/is_reference.h>	254	# include <__type_traits/is_reference.h>
254	# include <__type_traits/is_replaceable.h>
255	# include <__type_traits/is_same.h>	255	# include <__type_traits/is_same.h>
256	# include <__type_traits/is_swappable.h>	256	# include <__type_traits/is_swappable.h>
257	# include <__type_traits/is_trivially_relocatable.h>	257	# include <__type_traits/is_trivially_relocatable.h>
...	@@ -263,12 +263,12 @@ template <class... Types>	...	@@ -263,12 +263,12 @@ template <class... Types>
263	# include <__type_traits/remove_cv.h>	263	# include <__type_traits/remove_cv.h>
264	# include <__type_traits/remove_cvref.h>	264	# include <__type_traits/remove_cvref.h>
265	# include <__type_traits/remove_reference.h>	265	# include <__type_traits/remove_reference.h>
		266	# include <__type_traits/type_list.h>
266	# include <__type_traits/unwrap_ref.h>	267	# include <__type_traits/unwrap_ref.h>
267	# include <__utility/declval.h>	268	# include <__utility/declval.h>
268	# include <__utility/forward.h>	269	# include <__utility/forward.h>
269	# include <__utility/integer_sequence.h>	270	# include <__utility/integer_sequence.h>
270	# include <__utility/move.h>	271	# include <__utility/move.h>
271	# include <__utility/piecewise_construct.h>
272	# include <__utility/swap.h>	272	# include <__utility/swap.h>
273	# include <version>	273	# include <version>
274		274
...	@@ -288,9 +288,65 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -288,9 +288,65 @@ _LIBCPP_BEGIN_NAMESPACE_STD
288		288
289	# ifndef _LIBCPP_CXX03_LANG	289	# ifndef _LIBCPP_CXX03_LANG
290		290
		291	template <size_t _Ip, class _Tp, class _Up>
		292	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool __tuple_compare_equal(const _Tp& __x, const _Up& __y) {
		293	if constexpr (_Ip == 0)
		294	return true;
		295	else
		296	return std::__tuple_compare_equal<_Ip - 1>(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
		297	}
		298
		299	# if _LIBCPP_STD_VER >= 26
		300	template <class _Tp, class _Up, class _IndexSeq = make_index_sequence<tuple_size_v<_Tp>>>
		301	inline constexpr bool __can_tuple_compare_equal = false;
		302
		303	// TODO(LLVM 23): Remove `tuple_size_v<_Tp> == tuple_size_v<_Up>` here once once LLVM-20 support ends
		304	// because the resolution of CWG2369 landed in LLVM-21.
		305	template <class _Tp, class _Up, size_t... _Is>
		306	requires(tuple_size_v<_Tp> == tuple_size_v<_Up>)
		307	inline constexpr bool __can_tuple_compare_equal<_Tp, _Up, index_sequence<_Is...>> =
		308	__all<requires(const tuple_element_t<_Is, _Tp>& __t, const tuple_element_t<_Is, _Up>& __u) {
		309	{ __t == __u } -> __boolean_testable;
		310	}...>::value;
		311	# endif // _LIBCPP_STD_VER >= 26
		312
		313	# if _LIBCPP_STD_VER >= 20
		314	template <class _Ret, class _Tp, class _Up, size_t... _Is>
		315	_LIBCPP_HIDE_FROM_ABI constexpr _Ret __tuple_compare_three_way(const _Tp& __x, const _Up& __y, index_sequence<_Is...>) {
		316	_Ret __result = strong_ordering::equal;
		317	static_cast<void>(
		318	((__result = std::__synth_three_way(std::get<_Is>(__x), std::get<_Is>(__y)), __result != 0) \|\| ...));
		319	return __result;
		320	}
		321	# endif // _LIBCPP_STD_VER >= 20
		322
		323	# if _LIBCPP_STD_VER >= 23
		324	template <class _Tp>
		325	concept __tuple_like_no_tuple = __tuple_like<_Tp> && !__is_tuple_v<_Tp>;
		326
		327	template <class _Tp, class _Up, class _IndexSeq>
		328	struct __tuple_common_comparison_category_impl {};
		329
		330	// TODO(LLVM 23): Remove `tuple_size_v<_Tp> == tuple_size_v<_Up>` here once once LLVM-20 support ends
		331	// because the resolution of CWG2369 landed in LLVM-21.
		332	template <class _Tp, class _Up, size_t... _Is>
		333	requires(tuple_size_v<_Tp> == tuple_size_v<_Up>) && requires {
		334	typename common_comparison_category_t<
		335	__synth_three_way_result<tuple_element_t<_Is, _Tp>, tuple_element_t<_Is, _Up>>...>;
		336	}
		337	struct __tuple_common_comparison_category_impl<_Tp, _Up, index_sequence<_Is...>> {
		338	using type _LIBCPP_NODEBUG =
		339	common_comparison_category_t<__synth_three_way_result<tuple_element_t<_Is, _Tp>, tuple_element_t<_Is, _Up>>...>;
		340	};
		341
		342	template <__tuple_like _Tp, __tuple_like _Up>
		343	using __tuple_common_comparison_category _LIBCPP_NODEBUG =
		344	__tuple_common_comparison_category_impl<_Tp, _Up, make_index_sequence<tuple_size_v<_Tp>>>::type;
		345	# endif // _LIBCPP_STD_VER >= 23
		346
291	// __tuple_leaf	347	// __tuple_leaf
292		348
293	template <size_t _Ip, class _Hp, bool = is_empty<_Hp>::value && !__libcpp_is_final<_Hp>::value >	349	template <size_t _Ip, class _Hp, bool = is_empty<_Hp>::value && !__is_final_v<_Hp> >
294	class __tuple_leaf;	350	class __tuple_leaf;
295		351
296	template <size_t _Ip, class _Hp, bool _Ep>	352	template <size_t _Ip, class _Hp, bool _Ep>
...	@@ -444,62 +500,52 @@ public:	...	@@ -444,62 +500,52 @@ public:
444	template <class... _Tp>	500	template <class... _Tp>
445	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swallow(_Tp&&...) _NOEXCEPT {}	501	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void __swallow(_Tp&&...) _NOEXCEPT {}
446		502
447	template <class _Tp>
448	struct __all_default_constructible;
449
450	template <class... _Tp>
451	struct __all_default_constructible<__tuple_types<_Tp...>> : __all<is_default_constructible<_Tp>::value...> {};
452
453	// __tuple_impl	503	// __tuple_impl
454		504
455	template <class _Indx, class... _Tp>	505	template <class _Indx, class... _Tp>
456	struct __tuple_impl;	506	struct __tuple_impl;
457		507
		508	struct __forward_args {};
		509	struct __value_init {};
		510	struct __from_tuple {};
		511
458	template <size_t... _Indx, class... _Tp>	512	template <size_t... _Indx, class... _Tp>
459	struct _LIBCPP_DECLSPEC_EMPTY_BASES	513	struct _LIBCPP_DECLSPEC_EMPTY_BASES
460	__tuple_impl<__tuple_indices<_Indx...>, _Tp...> : public __tuple_leaf<_Indx, _Tp>... {	514	__tuple_impl<__index_sequence<_Indx...>, _Tp...> : public __tuple_leaf<_Indx, _Tp>... {
461	_LIBCPP_HIDE_FROM_ABI constexpr __tuple_impl() noexcept(	515	_LIBCPP_HIDE_FROM_ABI constexpr __tuple_impl() noexcept(
462	__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}	516	__all<is_nothrow_default_constructible<_Tp>::value...>::value) {}
463		517
464	template <size_t... _Uf, class... _Tf, size_t... _Ul, class... _Tl, class... _Up>	518	template <class... _Args>
465	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(	519	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(__forward_args, _Args&&... __args)
466	__tuple_indices<_Uf...>,	520	: __tuple_leaf<_Indx, _Tp>(std::forward<_Args>(__args))... {}
467	__tuple_types<_Tf...>,	521
468	__tuple_indices<_Ul...>,	522	template <class _Alloc>
469	__tuple_types<_Tl...>,	523	_LIBCPP_HIDE_FROM_ABI
470	_Up&&... __u) noexcept(__all<is_nothrow_constructible<_Tf, _Up>::value...>::value &&	524	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(allocator_arg_t, const _Alloc& __alloc, __value_init)
471	__all<is_nothrow_default_constructible<_Tl>::value...>::value)	525	: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc>(), __alloc)... {}
472	: __tuple_leaf<_Uf, _Tf>(std::forward<_Up>(__u))..., __tuple_leaf<_Ul, _Tl>()... {}	526
473		527	template <class _Alloc, class... _Args>
474	template <class _Alloc, size_t... _Uf, class... _Tf, size_t... _Ul, class... _Tl, class... _Up>
475	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(	528	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit __tuple_impl(
476	allocator_arg_t,	529	allocator_arg_t, const _Alloc& __alloc, __forward_args, _Args&&... __args)
477	const _Alloc& __a,	530	: __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, _Args>(), __alloc, std::forward<_Args>(__args))... {}
478	__tuple_indices<_Uf...>,	531
479	__tuple_types<_Tf...>,	532	template <class _Tuple>
480	__tuple_indices<_Ul...>,	533	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_impl(__from_tuple, _Tuple&& __t) noexcept(
481	__tuple_types<_Tl...>,	534	(__all<is_nothrow_constructible<_Tp, __copy_cvref_t<_Tuple, __tuple_element_t<_Indx, __remove_cvref_t<_Tuple>>>>::
482	_Up&&... __u)	535	value...>::value))
483	: __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a, std::forward<_Up>(__u))...,
484	__tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)... {}
485
486	template <class _Tuple, __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value, int> = 0>
487	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_impl(_Tuple&& __t) noexcept(
488	(__all<is_nothrow_constructible<
489	_Tp,
490	typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>::value...>::value))
491	: __tuple_leaf<_Indx, _Tp>(	536	: __tuple_leaf<_Indx, _Tp>(
492	std::forward<typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(	537	std::forward<__copy_cvref_t<_Tuple, __tuple_element_t<_Indx, __remove_cvref_t<_Tuple>>>>(
493	std::get<_Indx>(__t)))... {}	538	std::get<_Indx>(__t)))... {}
494		539
495	template <class _Alloc, class _Tuple, __enable_if_t<__tuple_constructible<_Tuple, tuple<_Tp...> >::value, int> = 0>	540	template <class _Alloc, class _Tuple>
496	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)	541	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
		542	__tuple_impl(allocator_arg_t, const _Alloc& __a, __from_tuple, _Tuple&& __t)
497	: __tuple_leaf<_Indx, _Tp>(	543	: __tuple_leaf<_Indx, _Tp>(
498	__uses_alloc_ctor<_Tp,	544	__uses_alloc_ctor<_Tp,
499	_Alloc,	545	_Alloc,
500	typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(),	546	__copy_cvref_t<_Tuple, __tuple_element_t<_Indx, __remove_cvref_t<_Tuple>>>>(),
501	__a,	547	__a,
502	std::forward<typename tuple_element<_Indx, typename __make_tuple_types<_Tuple>::type>::type>(	548	std::forward<__copy_cvref_t<_Tuple, __tuple_element_t<_Indx, __remove_cvref_t<_Tuple>>>>(
503	std::get<_Indx>(__t)))... {}	549	std::get<_Indx>(__t)))... {}
504		550
505	__tuple_impl(const __tuple_impl&) = default;	551	__tuple_impl(const __tuple_impl&) = default;
...	@@ -518,19 +564,19 @@ struct _LIBCPP_DECLSPEC_EMPTY_BASES	...	@@ -518,19 +564,19 @@ struct _LIBCPP_DECLSPEC_EMPTY_BASES
518		564
519	template <class _Dest, class _Source, size_t... _Np>	565	template <class _Dest, class _Source, size_t... _Np>
520	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void	566	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
521	__memberwise_copy_assign(_Dest& __dest, _Source const& __source, __tuple_indices<_Np...>) {	567	__memberwise_copy_assign(_Dest& __dest, _Source const& __source, __index_sequence<_Np...>) {
522	std::__swallow(((std::get<_Np>(__dest) = std::get<_Np>(__source)), void(), 0)...);	568	std::__swallow(((std::get<_Np>(__dest) = std::get<_Np>(__source)), void(), 0)...);
523	}	569	}
524		570
525	template <class _Dest, class _Source, class... _Up, size_t... _Np>	571	template <class _Dest, class _Source, class... _Up, size_t... _Np>
526	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void	572	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 void
527	__memberwise_forward_assign(_Dest& __dest, _Source&& __source, __tuple_types<_Up...>, __tuple_indices<_Np...>) {	573	__memberwise_forward_assign(_Dest& __dest, _Source&& __source, __type_list<_Up...>, __index_sequence<_Np...>) {
528	std::__swallow(((std::get<_Np>(__dest) = std::forward<_Up>(std::get<_Np>(__source))), void(), 0)...);	574	std::__swallow(((std::get<_Np>(__dest) = std::forward<_Up>(std::get<_Np>(__source))), void(), 0)...);
529	}	575	}
530		576
531	template <class... _Tp>	577	template <class... _Tp>
532	class _LIBCPP_NO_SPECIALIZATIONS tuple {	578	class _LIBCPP_NO_SPECIALIZATIONS tuple {
533	typedef __tuple_impl<typename __make_tuple_indices<sizeof...(_Tp)>::type, _Tp...> _BaseT;	579	typedef __tuple_impl<__index_sequence_for<_Tp...>, _Tp...> _BaseT;
534		580
535	_BaseT __base_;	581	_BaseT __base_;
536		582
...	@@ -549,7 +595,6 @@ class _LIBCPP_NO_SPECIALIZATIONS tuple {	...	@@ -549,7 +595,6 @@ class _LIBCPP_NO_SPECIALIZATIONS tuple {
549	public:	595	public:
550	using __trivially_relocatable _LIBCPP_NODEBUG =	596	using __trivially_relocatable _LIBCPP_NODEBUG =
551	__conditional_t<_And<__libcpp_is_trivially_relocatable<_Tp>...>::value, tuple, void>;	597	__conditional_t<_And<__libcpp_is_trivially_relocatable<_Tp>...>::value, tuple, void>;
552	using __replaceable _LIBCPP_NODEBUG = __conditional_t<_And<__is_replaceable<_Tp>...>::value, tuple, void>;
553		598
554	// [tuple.cnstr]	599	// [tuple.cnstr]
555		600
...	@@ -566,12 +611,7 @@ public:	...	@@ -566,12 +611,7 @@ public:
566	__enable_if_t< _And< _IsDefault<_Tp>... >::value, int> = 0>	611	__enable_if_t< _And< _IsDefault<_Tp>... >::value, int> = 0>
567	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, _IsImpDefault<_Tp>...> >::value)	612	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, _IsImpDefault<_Tp>...> >::value)
568	tuple(allocator_arg_t, _Alloc const& __a)	613	tuple(allocator_arg_t, _Alloc const& __a)
569	: __base_(allocator_arg_t(),	614	: __base_(allocator_arg_t(), __a, __value_init{}) {}
570	__a,
571	__tuple_indices<>(),
572	__tuple_types<>(),
573	typename __make_tuple_indices<sizeof...(_Tp), 0>::type(),
574	__tuple_types<_Tp...>()) {}
575		615
576	// tuple(const T&...) constructors (including allocator_arg_t variants)	616	// tuple(const T&...) constructors (including allocator_arg_t variants)
577	template <template <class...> class _And = _And,	617	template <template <class...> class _And = _And,
...	@@ -579,11 +619,7 @@ public:	...	@@ -579,11 +619,7 @@ public:
579	_LIBCPP_HIDE_FROM_ABI	619	_LIBCPP_HIDE_FROM_ABI
580	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> >::value)	620	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> >::value)
581	tuple(const _Tp&... __t) noexcept(_And<is_nothrow_copy_constructible<_Tp>...>::value)	621	tuple(const _Tp&... __t) noexcept(_And<is_nothrow_copy_constructible<_Tp>...>::value)
582	: __base_(typename __make_tuple_indices<sizeof...(_Tp)>::type(),	622	: __base_(__forward_args{}, __t...) {}
583	typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
584	typename __make_tuple_indices<0>::type(),
585	typename __make_tuple_types<tuple, 0>::type(),
586	__t...) {}
587		623
588	template <class _Alloc,	624	template <class _Alloc,
589	template <class...> class _And = _And,	625	template <class...> class _And = _And,
...	@@ -591,13 +627,7 @@ public:	...	@@ -591,13 +627,7 @@ public:
591	_LIBCPP_HIDE_FROM_ABI	627	_LIBCPP_HIDE_FROM_ABI
592	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> >::value)	628	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<const _Tp&, _Tp>...> >::value)
593	tuple(allocator_arg_t, const _Alloc& __a, const _Tp&... __t)	629	tuple(allocator_arg_t, const _Alloc& __a, const _Tp&... __t)
594	: __base_(allocator_arg_t(),	630	: __base_(allocator_arg_t(), __a, __forward_args{}, __t...) {}
595	__a,
596	typename __make_tuple_indices<sizeof...(_Tp)>::type(),
597	typename __make_tuple_types<tuple, sizeof...(_Tp)>::type(),
598	typename __make_tuple_indices<0>::type(),
599	typename __make_tuple_types<tuple, 0>::type(),
600	__t...) {}
601		631
602	// tuple(U&& ...) constructors (including allocator_arg_t variants)	632	// tuple(U&& ...) constructors (including allocator_arg_t variants)
603	template <class... _Up>	633	template <class... _Up>
...	@@ -616,11 +646,7 @@ public:	...	@@ -616,11 +646,7 @@ public:
616	int> = 0>	646	int> = 0>
617	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)	647	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
618	tuple(_Up&&... __u) noexcept(_And<is_nothrow_constructible<_Tp, _Up>...>::value)	648	tuple(_Up&&... __u) noexcept(_And<is_nothrow_constructible<_Tp, _Up>...>::value)
619	: __base_(typename __make_tuple_indices<sizeof...(_Up)>::type(),	649	: __base_(__forward_args{}, std::forward<_Up>(__u)...) {}
620	typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
621	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
622	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
623	std::forward<_Up>(__u)...) {}
624		650
625	template <class _Alloc,	651	template <class _Alloc,
626	class... _Up,	652	class... _Up,
...	@@ -628,13 +654,7 @@ public:	...	@@ -628,13 +654,7 @@ public:
628	int> = 0>	654	int> = 0>
629	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)	655	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
630	tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)	656	tuple(allocator_arg_t, const _Alloc& __a, _Up&&... __u)
631	: __base_(allocator_arg_t(),	657	: __base_(allocator_arg_t(), __a, __forward_args{}, std::forward<_Up>(__u)...) {}
632	__a,
633	typename __make_tuple_indices<sizeof...(_Up)>::type(),
634	typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
635	typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
636	typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
637	std::forward<_Up>(__u)...) {}
638		658
639	// Copy and move constructors (including the allocator_arg_t variants)	659	// Copy and move constructors (including the allocator_arg_t variants)
640	tuple(const tuple&) = default;	660	tuple(const tuple&) = default;
...	@@ -644,13 +664,13 @@ public:	...	@@ -644,13 +664,13 @@ public:
644	template <class...> class _And = _And,	664	template <class...> class _And = _And,
645	__enable_if_t< _And<is_copy_constructible<_Tp>...>::value, int> = 0>	665	__enable_if_t< _And<is_copy_constructible<_Tp>...>::value, int> = 0>
646	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)	666	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc& __alloc, const tuple& __t)
647	: __base_(allocator_arg_t(), __alloc, __t) {}	667	: __base_(allocator_arg_t(), __alloc, __from_tuple(), __t) {}
648		668
649	template <class _Alloc,	669	template <class _Alloc,
650	template <class...> class _And = _And,	670	template <class...> class _And = _And,
651	__enable_if_t< _And<is_move_constructible<_Tp>...>::value, int> = 0>	671	__enable_if_t< _And<is_move_constructible<_Tp>...>::value, int> = 0>
652	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)	672	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple(allocator_arg_t, const _Alloc& __alloc, tuple&& __t)
653	: __base_(allocator_arg_t(), __alloc, std::move(__t)) {}	673	: __base_(allocator_arg_t(), __alloc, __from_tuple(), std::move(__t)) {}
654		674
655	// tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)	675	// tuple(const tuple<U...>&) constructors (including allocator_arg_t variants)
656		676
...	@@ -683,7 +703,7 @@ public:	...	@@ -683,7 +703,7 @@ public:
683	_LIBCPP_HIDE_FROM_ABI	703	_LIBCPP_HIDE_FROM_ABI
684	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> >::value)	704	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> >::value)
685	tuple(const tuple<_Up...>& __t) noexcept(_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)	705	tuple(const tuple<_Up...>& __t) noexcept(_And<is_nothrow_constructible<_Tp, const _Up&>...>::value)
686	: __base_(__t) {}	706	: __base_(__from_tuple(), __t) {}
687		707
688	template <class... _Up,	708	template <class... _Up,
689	class _Alloc,	709	class _Alloc,
...	@@ -691,33 +711,33 @@ public:	...	@@ -691,33 +711,33 @@ public:
691	_LIBCPP_HIDE_FROM_ABI	711	_LIBCPP_HIDE_FROM_ABI
692	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> >::value)	712	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<const _Up&, _Tp>...> >::value)
693	tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)	713	tuple(allocator_arg_t, const _Alloc& __a, const tuple<_Up...>& __t)
694	: __base_(allocator_arg_t(), __a, __t) {}	714	: __base_(allocator_arg_t(), __a, __from_tuple(), __t) {}
695		715
696	# if _LIBCPP_STD_VER >= 23	716	# if _LIBCPP_STD_VER >= 23
697	// tuple(tuple<U...>&) constructors (including allocator_arg_t variants)	717	// tuple(tuple<U...>&) constructors (including allocator_arg_t variants)
698		718
699	template <class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>	719	template <class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
700	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value) tuple(tuple<_Up...>& __t)	720	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value) tuple(tuple<_Up...>& __t)
701	: __base_(__t) {}	721	: __base_(__from_tuple(), __t) {}
702		722
703	template <class _Alloc, class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>	723	template <class _Alloc, class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<tuple<_Up...>&>::value>* = nullptr>
704	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)	724	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<_Up&, _Tp>...>::value)
705	tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t)	725	tuple(allocator_arg_t, const _Alloc& __alloc, tuple<_Up...>& __t)
706	: __base_(allocator_arg_t(), __alloc, __t) {}	726	: __base_(allocator_arg_t(), __alloc, __from_tuple(), __t) {}
707	# endif // _LIBCPP_STD_VER >= 23	727	# endif // _LIBCPP_STD_VER >= 23
708		728
709	// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)	729	// tuple(tuple<U...>&&) constructors (including allocator_arg_t variants)
710	template <class... _Up, __enable_if_t< _And< _EnableCtorFromUTypesTuple<tuple<_Up...>&&> >::value, int> = 0>	730	template <class... _Up, __enable_if_t< _And< _EnableCtorFromUTypesTuple<tuple<_Up...>&&> >::value, int> = 0>
711	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)	731	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
712	tuple(tuple<_Up...>&& __t) noexcept(_And<is_nothrow_constructible<_Tp, _Up>...>::value)	732	tuple(tuple<_Up...>&& __t) noexcept(_And<is_nothrow_constructible<_Tp, _Up>...>::value)
713	: __base_(std::move(__t)) {}	733	: __base_(__from_tuple(), std::move(__t)) {}
714		734
715	template <class _Alloc,	735	template <class _Alloc,
716	class... _Up,	736	class... _Up,
717	__enable_if_t< _And< _EnableCtorFromUTypesTuple<tuple<_Up...>&&> >::value, int> = 0>	737	__enable_if_t< _And< _EnableCtorFromUTypesTuple<tuple<_Up...>&&> >::value, int> = 0>
718	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)	738	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_Lazy<_And, is_convertible<_Up, _Tp>...> >::value)
719	tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)	739	tuple(allocator_arg_t, const _Alloc& __a, tuple<_Up...>&& __t)
720	: __base_(allocator_arg_t(), __a, std::move(__t)) {}	740	: __base_(allocator_arg_t(), __a, __from_tuple(), std::move(__t)) {}
721		741
722	# if _LIBCPP_STD_VER >= 23	742	# if _LIBCPP_STD_VER >= 23
723	// tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)	743	// tuple(const tuple<U...>&&) constructors (including allocator_arg_t variants)
...	@@ -725,14 +745,14 @@ public:	...	@@ -725,14 +745,14 @@ public:
725	template <class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>	745	template <class... _Up, enable_if_t< _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
726	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)	746	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
727	tuple(const tuple<_Up...>&& __t)	747	tuple(const tuple<_Up...>&& __t)
728	: __base_(std::move(__t)) {}	748	: __base_(__from_tuple(), std::move(__t)) {}
729		749
730	template <class _Alloc,	750	template <class _Alloc,
731	class... _Up,	751	class... _Up,
732	enable_if_t< _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>	752	enable_if_t< _EnableCtorFromUTypesTuple<const tuple<_Up...>&&>::value>* = nullptr>
733	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)	753	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_Lazy<_And, is_convertible<const _Up&&, _Tp>...>::value)
734	tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)	754	tuple(allocator_arg_t, const _Alloc& __alloc, const tuple<_Up...>&& __t)
735	: __base_(allocator_arg_t(), __alloc, std::move(__t)) {}	755	: __base_(allocator_arg_t(), __alloc, __from_tuple(), std::move(__t)) {}
736	# endif // _LIBCPP_STD_VER >= 23	756	# endif // _LIBCPP_STD_VER >= 23
737		757
738	// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)	758	// tuple(const pair<U1, U2>&) constructors (including allocator_arg_t variants)
...	@@ -767,7 +787,7 @@ public:	...	@@ -767,7 +787,7 @@ public:
767	_LIBCPP_HIDE_FROM_ABI	787	_LIBCPP_HIDE_FROM_ABI
768	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> >::value)	788	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> >::value)
769	tuple(const pair<_Up1, _Up2>& __p) noexcept(_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value)	789	tuple(const pair<_Up1, _Up2>& __p) noexcept(_NothrowConstructibleFromPair<const pair<_Up1, _Up2>&>::value)
770	: __base_(__p) {}	790	: __base_(__from_tuple(), __p) {}
771		791
772	template <class _Alloc,	792	template <class _Alloc,
773	class _Up1,	793	class _Up1,
...	@@ -777,7 +797,7 @@ public:	...	@@ -777,7 +797,7 @@ public:
777	_LIBCPP_HIDE_FROM_ABI	797	_LIBCPP_HIDE_FROM_ABI
778	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> >::value)	798	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_BothImplicitlyConvertible<const pair<_Up1, _Up2>&> >::value)
779	tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)	799	tuple(allocator_arg_t, const _Alloc& __a, const pair<_Up1, _Up2>& __p)
780	: __base_(allocator_arg_t(), __a, __p) {}	800	: __base_(allocator_arg_t(), __a, __from_tuple(), __p) {}
781		801
782	# if _LIBCPP_STD_VER >= 23	802	# if _LIBCPP_STD_VER >= 23
783	// tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)	803	// tuple(pair<U1, U2>&) constructors (including allocator_arg_t variants)
...	@@ -785,7 +805,7 @@ public:	...	@@ -785,7 +805,7 @@ public:
785	template <class _U1, class _U2, enable_if_t< _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>	805	template <class _U1, class _U2, enable_if_t< _EnableCtorFromPair<pair<_U1, _U2>&>::value>* = nullptr>
786	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)	806	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
787	tuple(pair<_U1, _U2>& __p)	807	tuple(pair<_U1, _U2>& __p)
788	: __base_(__p) {}	808	: __base_(__from_tuple(), __p) {}
789		809
790	template <class _Alloc,	810	template <class _Alloc,
791	class _U1,	811	class _U1,
...	@@ -793,7 +813,7 @@ public:	...	@@ -793,7 +813,7 @@ public:
793	enable_if_t< _EnableCtorFromPair<std::pair<_U1, _U2>&>::value>* = nullptr>	813	enable_if_t< _EnableCtorFromPair<std::pair<_U1, _U2>&>::value>* = nullptr>
794	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)	814	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<pair<_U1, _U2>&>::value)
795	tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p)	815	tuple(allocator_arg_t, const _Alloc& __alloc, pair<_U1, _U2>& __p)
796	: __base_(allocator_arg_t(), __alloc, __p) {}	816	: __base_(allocator_arg_t(), __alloc, __from_tuple(), __p) {}
797	# endif	817	# endif
798		818
799	// tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)	819	// tuple(pair<U1, U2>&&) constructors (including allocator_arg_t variants)
...	@@ -805,7 +825,7 @@ public:	...	@@ -805,7 +825,7 @@ public:
805	_LIBCPP_HIDE_FROM_ABI	825	_LIBCPP_HIDE_FROM_ABI
806	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> >::value)	826	_LIBCPP_CONSTEXPR_SINCE_CXX14 explicit(_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> >::value)
807	tuple(pair<_Up1, _Up2>&& __p) noexcept(_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value)	827	tuple(pair<_Up1, _Up2>&& __p) noexcept(_NothrowConstructibleFromPair<pair<_Up1, _Up2>&&>::value)
808	: __base_(std::move(__p)) {}	828	: __base_(__from_tuple(), std::move(__p)) {}
809		829
810	template <class _Alloc,	830	template <class _Alloc,
811	class _Up1,	831	class _Up1,
...	@@ -815,7 +835,7 @@ public:	...	@@ -815,7 +835,7 @@ public:
815	_LIBCPP_HIDE_FROM_ABI	835	_LIBCPP_HIDE_FROM_ABI
816	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> >::value)	836	_LIBCPP_CONSTEXPR_SINCE_CXX20 explicit(_Not<_BothImplicitlyConvertible<pair<_Up1, _Up2>&&> >::value)
817	tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)	837	tuple(allocator_arg_t, const _Alloc& __a, pair<_Up1, _Up2>&& __p)
818	: __base_(allocator_arg_t(), __a, std::move(__p)) {}	838	: __base_(allocator_arg_t(), __a, __from_tuple(), std::move(__p)) {}
819		839
820	# if _LIBCPP_STD_VER >= 23	840	# if _LIBCPP_STD_VER >= 23
821	// tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)	841	// tuple(const pair<U1, U2>&&) constructors (including allocator_arg_t variants)
...	@@ -823,7 +843,7 @@ public:	...	@@ -823,7 +843,7 @@ public:
823	template <class _U1, class _U2, enable_if_t< _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>	843	template <class _U1, class _U2, enable_if_t< _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
824	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)	844	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
825	tuple(const pair<_U1, _U2>&& __p)	845	tuple(const pair<_U1, _U2>&& __p)
826	: __base_(std::move(__p)) {}	846	: __base_(__from_tuple(), std::move(__p)) {}
827		847
828	template <class _Alloc,	848	template <class _Alloc,
829	class _U1,	849	class _U1,
...	@@ -831,14 +851,14 @@ public:	...	@@ -831,14 +851,14 @@ public:
831	enable_if_t< _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>	851	enable_if_t< _EnableCtorFromPair<const pair<_U1, _U2>&&>::value>* = nullptr>
832	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)	852	_LIBCPP_HIDE_FROM_ABI constexpr explicit(!_BothImplicitlyConvertible<const pair<_U1, _U2>&&>::value)
833	tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)	853	tuple(allocator_arg_t, const _Alloc& __alloc, const pair<_U1, _U2>&& __p)
834	: __base_(allocator_arg_t(), __alloc, std::move(__p)) {}	854	: __base_(allocator_arg_t(), __alloc, __from_tuple(), std::move(__p)) {}
835	# endif // _LIBCPP_STD_VER >= 23	855	# endif // _LIBCPP_STD_VER >= 23
836		856
837	// [tuple.assign]	857	// [tuple.assign]
838	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&	858	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
839	operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple) noexcept(	859	operator=(_If<_And<is_copy_assignable<_Tp>...>::value, tuple, __nat> const& __tuple) noexcept(
840	_And<is_nothrow_copy_assignable<_Tp>...>::value) {	860	_And<is_nothrow_copy_assignable<_Tp>...>::value) {
841	std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());	861	std::__memberwise_copy_assign(*this, __tuple, __index_sequence_for<_Tp...>());
842	return *this;	862	return *this;
843	}	863	}
844		864
...	@@ -846,15 +866,14 @@ public:	...	@@ -846,15 +866,14 @@ public:
846	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple const& __tuple) const	866	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple const& __tuple) const
847	requires(_And<is_copy_assignable<const _Tp>...>::value)	867	requires(_And<is_copy_assignable<const _Tp>...>::value)
848	{	868	{
849	std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());	869	std::__memberwise_copy_assign(*this, __tuple, __index_sequence_for<_Tp...>());
850	return *this;	870	return *this;
851	}	871	}
852		872
853	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple&& __tuple) const	873	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple&& __tuple) const
854	requires(_And<is_assignable<const _Tp&, _Tp>...>::value)	874	requires(_And<is_assignable<const _Tp&, _Tp>...>::value)
855	{	875	{
856	std::__memberwise_forward_assign(	876	std::__memberwise_forward_assign(*this, std::move(__tuple), __type_list<_Tp...>(), __index_sequence_for<_Tp...>());
857	*this, std::move(__tuple), __tuple_types<_Tp...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
858	return *this;	877	return *this;
859	}	878	}
860	# endif // _LIBCPP_STD_VER >= 23	879	# endif // _LIBCPP_STD_VER >= 23
...	@@ -862,8 +881,7 @@ public:	...	@@ -862,8 +881,7 @@ public:
862	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&	881	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
863	operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple) noexcept(	882	operator=(_If<_And<is_move_assignable<_Tp>...>::value, tuple, __nat>&& __tuple) noexcept(
864	_And<is_nothrow_move_assignable<_Tp>...>::value) {	883	_And<is_nothrow_move_assignable<_Tp>...>::value) {
865	std::__memberwise_forward_assign(	884	std::__memberwise_forward_assign(*this, std::move(__tuple), __type_list<_Tp...>(), __index_sequence_for<_Tp...>());
866	*this, std::move(__tuple), __tuple_types<_Tp...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
867	return *this;	885	return *this;
868	}	886	}
869		887
...	@@ -873,7 +891,7 @@ public:	...	@@ -873,7 +891,7 @@ public:
873	int> = 0>	891	int> = 0>
874	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&	892	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
875	operator=(tuple<_Up...> const& __tuple) noexcept(_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value) {	893	operator=(tuple<_Up...> const& __tuple) noexcept(_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value) {
876	std::__memberwise_copy_assign(*this, __tuple, typename __make_tuple_indices<sizeof...(_Tp)>::type());	894	std::__memberwise_copy_assign(*this, __tuple, __index_sequence_for<_Tp...>());
877	return *this;	895	return *this;
878	}	896	}
879		897
...	@@ -882,8 +900,7 @@ public:	...	@@ -882,8 +900,7 @@ public:
882	int> = 0>	900	int> = 0>
883	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&	901	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
884	operator=(tuple<_Up...>&& __tuple) noexcept(_And<is_nothrow_assignable<_Tp&, _Up>...>::value) {	902	operator=(tuple<_Up...>&& __tuple) noexcept(_And<is_nothrow_assignable<_Tp&, _Up>...>::value) {
885	std::__memberwise_forward_assign(	903	std::__memberwise_forward_assign(*this, std::move(__tuple), __type_list<_Up...>(), __index_sequence_for<_Tp...>());
886	*this, std::move(__tuple), __tuple_types<_Up...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
887	return *this;	904	return *this;
888	}	905	}
889		906
...	@@ -892,7 +909,7 @@ public:	...	@@ -892,7 +909,7 @@ public:
892	enable_if_t< _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,	909	enable_if_t< _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
893	is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>	910	is_assignable<const _Tp&, const _UTypes&>...>::value>* = nullptr>
894	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(const tuple<_UTypes...>& __u) const {	911	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(const tuple<_UTypes...>& __u) const {
895	std::__memberwise_copy_assign(*this, __u, typename __make_tuple_indices<sizeof...(_Tp)>::type());	912	std::__memberwise_copy_assign(*this, __u, index_sequence_for<_Tp...>());
896	return *this;	913	return *this;
897	}	914	}
898		915
...	@@ -900,8 +917,7 @@ public:	...	@@ -900,8 +917,7 @@ public:
900	enable_if_t< _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,	917	enable_if_t< _And<_BoolConstant<sizeof...(_Tp) == sizeof...(_UTypes)>,
901	is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>	918	is_assignable<const _Tp&, _UTypes>...>::value>* = nullptr>
902	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple<_UTypes...>&& __u) const {	919	_LIBCPP_HIDE_FROM_ABI constexpr const tuple& operator=(tuple<_UTypes...>&& __u) const {
903	std::__memberwise_forward_assign(	920	std::__memberwise_forward_assign(*this, __u, __type_list<_UTypes...>(), index_sequence_for<_Tp...>());
904	*this, __u, __tuple_types<_UTypes...>(), typename __make_tuple_indices<sizeof...(_Tp)>::type());
905	return *this;	921	return *this;
906	}	922	}
907	# endif // _LIBCPP_STD_VER >= 23	923	# endif // _LIBCPP_STD_VER >= 23
...	@@ -967,7 +983,7 @@ public:	...	@@ -967,7 +983,7 @@ public:
967	__enable_if_t< _And< _BoolConstant<_Np == sizeof...(_Tp)>, is_assignable<_Tp&, _Up const&>... >::value, int> = 0>	983	__enable_if_t< _And< _BoolConstant<_Np == sizeof...(_Tp)>, is_assignable<_Tp&, _Up const&>... >::value, int> = 0>
968	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&	984	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
969	operator=(array<_Up, _Np> const& __array) noexcept(_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value) {	985	operator=(array<_Up, _Np> const& __array) noexcept(_And<is_nothrow_assignable<_Tp&, _Up const&>...>::value) {
970	std::__memberwise_copy_assign(*this, __array, typename __make_tuple_indices<sizeof...(_Tp)>::type());	986	std::__memberwise_copy_assign(*this, __array, __index_sequence_for<_Tp...>());
971	return *this;	987	return *this;
972	}	988	}
973		989
...	@@ -979,10 +995,7 @@ public:	...	@@ -979,10 +995,7 @@ public:
979	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&	995	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 tuple&
980	operator=(array<_Up, _Np>&& __array) noexcept(_And<is_nothrow_assignable<_Tp&, _Up>...>::value) {	996	operator=(array<_Up, _Np>&& __array) noexcept(_And<is_nothrow_assignable<_Tp&, _Up>...>::value) {
981	std::__memberwise_forward_assign(	997	std::__memberwise_forward_assign(
982	*this,	998	*this, std::move(__array), __type_list<_If<true, _Up, _Tp>...>(), __index_sequence_for<_Tp...>());
983	std::move(__array),
984	__tuple_types<_If<true, _Up, _Tp>...>(),
985	typename __make_tuple_indices<sizeof...(_Tp)>::type());
986	return *this;	999	return *this;
987	}	1000	}
988		1001
...	@@ -997,7 +1010,24 @@ public:	...	@@ -997,7 +1010,24 @@ public:
997	noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {	1010	noexcept(__all<is_nothrow_swappable_v<const _Tp&>...>::value) {
998	__base_.swap(__t.__base_);	1011	__base_.swap(__t.__base_);
999	}	1012	}
1000	# endif // _LIBCPP_STD_VER >= 23	1013
		1014	template <__tuple_like_no_tuple _UTuple>
		1015	# if _LIBCPP_STD_VER >= 26
		1016	requires __can_tuple_compare_equal<tuple, _UTuple> && (sizeof...(_Tp) == tuple_size_v<_UTuple>)
		1017	# endif // _LIBCPP_STD_VER >= 26
		1018	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const tuple& __x, const _UTuple& __y) {
		1019	static_assert(sizeof...(_Tp) == tuple_size_v<_UTuple>, "Can't compare tuple-like values of different sizes");
		1020	return std::__tuple_compare_equal<sizeof...(_Tp)>(__x, __y);
		1021	}
		1022
		1023	template <__tuple_like_no_tuple _UTuple>
		1024	requires(sizeof...(_Tp) == tuple_size_v<_UTuple>)
		1025	_LIBCPP_HIDE_FROM_ABI friend constexpr __tuple_common_comparison_category<tuple, _UTuple>
		1026	operator<=>(const tuple& __x, const _UTuple& __y) {
		1027	return std::__tuple_compare_three_way<__tuple_common_comparison_category<tuple, _UTuple>>(
		1028	__x, __y, index_sequence_for<_Tp...>{});
		1029	}
		1030	# endif // _LIBCPP_STD_VER >= 23
1001	};	1031	};
1002		1032
1003	_LIBCPP_DIAGNOSTIC_PUSH	1033	_LIBCPP_DIAGNOSTIC_PUSH
...	@@ -1019,6 +1049,21 @@ public:	...	@@ -1019,6 +1049,21 @@ public:
1019	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(tuple&) _NOEXCEPT {}	1049	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void swap(tuple&) _NOEXCEPT {}
1020	# if _LIBCPP_STD_VER >= 23	1050	# if _LIBCPP_STD_VER >= 23
1021	_LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}	1051	_LIBCPP_HIDE_FROM_ABI constexpr void swap(const tuple&) const noexcept {}
		1052
		1053	template <__tuple_like_no_tuple _UTuple>
		1054	# if _LIBCPP_STD_VER >= 26
		1055	requires(tuple_size_v<_UTuple> == 0)
		1056	# endif // _LIBCPP_STD_VER >= 26
		1057	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const tuple&, const _UTuple&) {
		1058	static_assert(tuple_size_v<_UTuple> == 0, "Can't compare tuple-like values of different sizes");
		1059	return true;
		1060	}
		1061
		1062	template <__tuple_like_no_tuple _UTuple>
		1063	requires(tuple_size_v<_UTuple> == 0)
		1064	_LIBCPP_HIDE_FROM_ABI friend constexpr strong_ordering operator<=>(const tuple&, const _UTuple&) {
		1065	return strong_ordering::equal;
		1066	}
1022	# endif	1067	# endif
1023	};	1068	};
1024	_LIBCPP_DIAGNOSTIC_POP	1069	_LIBCPP_DIAGNOSTIC_POP
...	@@ -1068,28 +1113,32 @@ swap(const tuple<_Tp...>& __lhs,	...	@@ -1068,28 +1113,32 @@ swap(const tuple<_Tp...>& __lhs,
1068	// get	1113	// get
1069		1114
1070	template <size_t _Ip, class... _Tp>	1115	template <size_t _Ip, class... _Tp>
1071	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, tuple<_Tp...> >::type&	1116	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
		1117	typename tuple_element<_Ip, tuple<_Tp...> >::type&
1072	get(tuple<_Tp...>& __t) _NOEXCEPT {	1118	get(tuple<_Tp...>& __t) _NOEXCEPT {
1073	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;	1119	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;
1074	return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();	1120	return static_cast<__tuple_leaf<_Ip, type>&>(__t.__base_).get();
1075	}	1121	}
1076		1122
1077	template <size_t _Ip, class... _Tp>	1123	template <size_t _Ip, class... _Tp>
1078	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&	1124	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
		1125	_LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
1079	get(const tuple<_Tp...>& __t) _NOEXCEPT {	1126	get(const tuple<_Tp...>& __t) _NOEXCEPT {
1080	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;	1127	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;
1081	return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();	1128	return static_cast<const __tuple_leaf<_Ip, type>&>(__t.__base_).get();
1082	}	1129	}
1083		1130
1084	template <size_t _Ip, class... _Tp>	1131	template <size_t _Ip, class... _Tp>
1085	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename tuple_element<_Ip, tuple<_Tp...> >::type&&	1132	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
		1133	typename tuple_element<_Ip, tuple<_Tp...> >::type&&
1086	get(tuple<_Tp...>&& __t) _NOEXCEPT {	1134	get(tuple<_Tp...>&& __t) _NOEXCEPT {
1087	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;	1135	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;
1088	return static_cast<type&&>(static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());	1136	return static_cast<type&&>(static_cast<__tuple_leaf<_Ip, type>&&>(__t.__base_).get());
1089	}	1137	}
1090		1138
1091	template <size_t _Ip, class... _Tp>	1139	template <size_t _Ip, class... _Tp>
1092	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&	1140	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
		1141	_LIBCPP_CONSTEXPR_SINCE_CXX14 const typename tuple_element<_Ip, tuple<_Tp...> >::type&&
1093	get(const tuple<_Tp...>&& __t) _NOEXCEPT {	1142	get(const tuple<_Tp...>&& __t) _NOEXCEPT {
1094	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;	1143	using type _LIBCPP_NODEBUG = typename tuple_element<_Ip, tuple<_Tp...> >::type;
1095	return static_cast<const type&&>(static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());	1144	return static_cast<const type&&>(static_cast<const __tuple_leaf<_Ip, type>&&>(__t.__base_).get());
...	@@ -1098,22 +1147,22 @@ get(const tuple<_Tp...>&& __t) _NOEXCEPT {	...	@@ -1098,22 +1147,22 @@ get(const tuple<_Tp...>&& __t) _NOEXCEPT {
1098	# if _LIBCPP_STD_VER >= 14	1147	# if _LIBCPP_STD_VER >= 14
1099		1148
1100	template <class _T1, class... _Args>	1149	template <class _T1, class... _Args>
1101	inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(tuple<_Args...>& __tup) noexcept {	1150	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1& get(tuple<_Args...>& __tup) noexcept {
1102	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);	1151	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1103	}	1152	}
1104		1153
1105	template <class _T1, class... _Args>	1154	template <class _T1, class... _Args>
1106	inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept {	1155	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const& get(tuple<_Args...> const& __tup) noexcept {
1107	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);	1156	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(__tup);
1108	}	1157	}
1109		1158
1110	template <class _T1, class... _Args>	1159	template <class _T1, class... _Args>
1111	inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept {	1160	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1&& get(tuple<_Args...>&& __tup) noexcept {
1112	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup));	1161	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup));
1113	}	1162	}
1114		1163
1115	template <class _T1, class... _Args>	1164	template <class _T1, class... _Args>
1116	inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept {	1165	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(tuple<_Args...> const&& __tup) noexcept {
1117	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup));	1166	return std::get<__find_exactly_one_t<_T1, _Args...>::value>(std::move(__tup));
1118	}	1167	}
1119		1168
...	@@ -1122,37 +1171,22 @@ inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(tuple<_Args...> const&& _	...	@@ -1122,37 +1171,22 @@ inline _LIBCPP_HIDE_FROM_ABI constexpr _T1 const&& get(tuple<_Args...> const&& _
1122	// tie	1171	// tie
1123		1172
1124	template <class... _Tp>	1173	template <class... _Tp>
1125	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&...> tie(_Tp&... __t) _NOEXCEPT {	1174	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&...> tie(_Tp&... __t) _NOEXCEPT {
1126	return tuple<_Tp&...>(__t...);	1175	return tuple<_Tp&...>(__t...);
1127	}	1176	}
1128		1177
1129	template <class... _Tp>	1178	template <class... _Tp>
1130	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<__unwrap_ref_decay_t<_Tp>...>	1179	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<__unwrap_ref_decay_t<_Tp>...>
1131	make_tuple(_Tp&&... __t) {	1180	make_tuple(_Tp&&... __t) {
1132	return tuple<__unwrap_ref_decay_t<_Tp>...>(std::forward<_Tp>(__t)...);	1181	return tuple<__unwrap_ref_decay_t<_Tp>...>(std::forward<_Tp>(__t)...);
1133	}	1182	}
1134		1183
1135	template <class... _Tp>	1184	template <class... _Tp>
1136	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&&...> forward_as_tuple(_Tp&&... __t) _NOEXCEPT {	1185	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<_Tp&&...>
		1186	forward_as_tuple(_Tp&&... __t) _NOEXCEPT {
1137	return tuple<_Tp&&...>(std::forward<_Tp>(__t)...);	1187	return tuple<_Tp&&...>(std::forward<_Tp>(__t)...);
1138	}	1188	}
1139		1189
1140	template <size_t _Ip>
1141	struct __tuple_equal {
1142	template <class _Tp, class _Up>
1143	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp& __x, const _Up& __y) {
1144	return __tuple_equal<_Ip - 1>()(__x, __y) && std::get<_Ip - 1>(__x) == std::get<_Ip - 1>(__y);
1145	}
1146	};
1147
1148	template <>
1149	struct __tuple_equal<0> {
1150	template <class _Tp, class _Up>
1151	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool operator()(const _Tp&, const _Up&) {
1152	return true;
1153	}
1154	};
1155
1156	template <class... _Tp, class... _Up>	1190	template <class... _Tp, class... _Up>
1157	# if _LIBCPP_STD_VER >= 26	1191	# if _LIBCPP_STD_VER >= 26
1158	requires(__all<requires(const _Tp& __t, const _Up& __u) {	1192	requires(__all<requires(const _Tp& __t, const _Up& __u) {
...	@@ -1162,27 +1196,19 @@ template <class... _Tp, class... _Up>	...	@@ -1162,27 +1196,19 @@ template <class... _Tp, class... _Up>
1162	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool	1196	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 bool
1163	operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {	1197	operator==(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
1164	static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");	1198	static_assert(sizeof...(_Tp) == sizeof...(_Up), "Can't compare tuples of different sizes");
1165	return __tuple_equal<sizeof...(_Tp)>()(__x, __y);	1199	return std::__tuple_compare_equal<sizeof...(_Tp)>(__x, __y);
1166	}	1200	}
1167		1201
1168	# if _LIBCPP_STD_VER >= 20	1202	# if _LIBCPP_STD_VER >= 20
1169		1203
1170	// operator<=>	1204	// operator<=>
1171		1205
1172	template <class... _Tp, class... _Up, size_t... _Is>
1173	_LIBCPP_HIDE_FROM_ABI constexpr auto
1174	__tuple_compare_three_way(const tuple<_Tp...>& __x, const tuple<_Up...>& __y, index_sequence<_Is...>) {
1175	common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...> __result = strong_ordering::equal;
1176	static_cast<void>(
1177	((__result = std::__synth_three_way(std::get<_Is>(__x), std::get<_Is>(__y)), __result != 0) \|\| ...));
1178	return __result;
1179	}
1180
1181	template <class... _Tp, class... _Up>	1206	template <class... _Tp, class... _Up>
1182	requires(sizeof...(_Tp) == sizeof...(_Up))	1207	requires(sizeof...(_Tp) == sizeof...(_Up))
1183	_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>	1208	_LIBCPP_HIDE_FROM_ABI constexpr common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>
1184	operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {	1209	operator<=>(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
1185	return std::__tuple_compare_three_way(__x, __y, index_sequence_for<_Tp...>{});	1210	return std::__tuple_compare_three_way<common_comparison_category_t<__synth_three_way_result<_Tp, _Up>...>>(
		1211	__x, __y, index_sequence_for<_Tp...>{});
1186	}	1212	}
1187		1213
1188	# else // _LIBCPP_STD_VER >= 20	1214	# else // _LIBCPP_STD_VER >= 20
...	@@ -1243,65 +1269,59 @@ operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {	...	@@ -1243,65 +1269,59 @@ operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y) {
1243		1269
1244	// tuple_cat	1270	// tuple_cat
1245		1271
1246	template <class _Tp, class _Up>	1272	template <class... _Tuples>
1247	struct __tuple_cat_type;	1273	struct __tuple_cat_return_impl;
1248		1274
1249	template <class... _Ttypes, class... _Utypes>	1275	template <class... _Types>
1250	struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> > {	1276	struct __tuple_cat_return_impl<tuple<_Types...>> {
1251	using type _LIBCPP_NODEBUG = tuple<_Ttypes..., _Utypes...>;	1277	using type _LIBCPP_NODEBUG = tuple<_Types...>;
1252	};	1278	};
1253		1279
1254	template <class _ResultTuple, bool _Is_Tuple0TupleLike, class... _Tuples>	1280	template <class... _Types0, class... _Types1, class... _Tuples>
1255	struct __tuple_cat_return_1 {};	1281	struct __tuple_cat_return_impl<tuple<_Types0...>, tuple<_Types1...>, _Tuples...>
		1282	: __tuple_cat_return_impl<tuple<_Types0..., _Types1...>, _Tuples...> {};
1256		1283
1257	template <class... _Types, class _Tuple0>	1284	template <class... _Types0, class _Tp, class _Up, class... _Tuples>
1258	struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0> {	1285	struct __tuple_cat_return_impl<tuple<_Types0...>, pair<_Tp, _Up>, _Tuples...>
1259	using type _LIBCPP_NODEBUG =	1286	: __tuple_cat_return_impl<tuple<_Types0..., _Tp, _Up>, _Tuples...> {};
1260	typename __tuple_cat_type< tuple<_Types...>,
1261	typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type >::type;
1262	};
1263
1264	template <class... _Types, class _Tuple0, class _Tuple1, class... _Tuples>
1265	struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
1266	: public __tuple_cat_return_1<
1267	typename __tuple_cat_type< tuple<_Types...>,
1268	typename __make_tuple_types<__remove_cvref_t<_Tuple0> >::type >::type,
1269	__tuple_like_ext<__libcpp_remove_reference_t<_Tuple1> >::value,
1270	_Tuple1,
1271	_Tuples...> {};
1272		1287
1273	template <class... _Tuples>	1288	template <class, class, class>
1274	struct __tuple_cat_return;	1289	struct __tuple_cat_array;
1275		1290
1276	template <class _Tuple0, class... _Tuples>	1291	template <class... _Types, class _ValueT, size_t... _Indices>
1277	struct __tuple_cat_return<_Tuple0, _Tuples...>	1292	struct __tuple_cat_array<tuple<_Types...>, _ValueT, __index_sequence<_Indices...>> {
1278	: public __tuple_cat_return_1<tuple<>,	1293	template <size_t>
1279	__tuple_like_ext<__libcpp_remove_reference_t<_Tuple0> >::value,	1294	using __value_type _LIBCPP_NODEBUG = _ValueT;
1280	_Tuple0,
1281	_Tuples...> {};
1282		1295
1283	template <>	1296	using type _LIBCPP_NODEBUG = tuple<_Types..., __value_type<_Indices>...>;
1284	struct __tuple_cat_return<> {
1285	using type _LIBCPP_NODEBUG = tuple<>;
1286	};	1297	};
1287		1298
1288	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<> tuple_cat() { return tuple<>(); }	1299	template <class... _Types, class _ValueT, size_t _Np, class... _Tuples>
		1300	struct __tuple_cat_return_impl<tuple<_Types...>, array<_ValueT, _Np>, _Tuples...>
		1301	: __tuple_cat_return_impl<typename __tuple_cat_array<tuple<_Types...>, _ValueT, __make_index_sequence<_Np>>::type,
		1302	_Tuples...> {};
		1303
		1304	template <class... _Tuples>
		1305	using __tuple_cat_return_t _LIBCPP_NODEBUG =
		1306	typename __tuple_cat_return_impl<tuple<>, __remove_cvref_t<_Tuples>...>::type;
		1307
		1308	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 tuple<> tuple_cat() { return tuple<>(); }
1289		1309
1290	template <class _Rp, class _Indices, class _Tuple0, class... _Tuples>	1310	template <class _Rp, class _Indices, class _Tuple0, class... _Tuples>
1291	struct __tuple_cat_return_ref_imp;	1311	struct __tuple_cat_return_ref_imp;
1292		1312
1293	template <class... _Types, size_t... _I0, class _Tuple0>	1313	template <class... _Types, size_t... _I0, class _Tuple0>
1294	struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0> {	1314	struct __tuple_cat_return_ref_imp<tuple<_Types...>, __index_sequence<_I0...>, _Tuple0> {
1295	using _T0 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple0>;	1315	using _T0 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple0>;
1296	typedef tuple<_Types..., __copy_cvref_t<_Tuple0, typename tuple_element<_I0, _T0>::type>&&...> type;	1316	typedef tuple<_Types..., __copy_cvref_t<_Tuple0, typename tuple_element<_I0, _T0>::type>&&...> type;
1297	};	1317	};
1298		1318
1299	template <class... _Types, size_t... _I0, class _Tuple0, class _Tuple1, class... _Tuples>	1319	template <class... _Types, size_t... _I0, class _Tuple0, class _Tuple1, class... _Tuples>
1300	struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0, _Tuple1, _Tuples...>	1320	struct __tuple_cat_return_ref_imp<tuple<_Types...>, __index_sequence<_I0...>, _Tuple0, _Tuple1, _Tuples...>
1301	: public __tuple_cat_return_ref_imp<	1321	: public __tuple_cat_return_ref_imp<
1302	tuple<_Types...,	1322	tuple<_Types...,
1303	__copy_cvref_t<_Tuple0, typename tuple_element<_I0, __libcpp_remove_reference_t<_Tuple0>>::type>&&...>,	1323	__copy_cvref_t<_Tuple0, typename tuple_element<_I0, __libcpp_remove_reference_t<_Tuple0>>::type>&&...>,
1304	typename __make_tuple_indices<tuple_size<__libcpp_remove_reference_t<_Tuple1> >::value>::type,	1324	__make_index_sequence<tuple_size<__libcpp_remove_reference_t<_Tuple1> >::value>,
1305	_Tuple1,	1325	_Tuple1,
1306	_Tuples...> {};	1326	_Tuples...> {};
1307		1327
...	@@ -1309,7 +1329,7 @@ template <class _Tuple0, class... _Tuples>	...	@@ -1309,7 +1329,7 @@ template <class _Tuple0, class... _Tuples>
1309	struct __tuple_cat_return_ref	1329	struct __tuple_cat_return_ref
1310	: public __tuple_cat_return_ref_imp<	1330	: public __tuple_cat_return_ref_imp<
1311	tuple<>,	1331	tuple<>,
1312	typename __make_tuple_indices< tuple_size<__libcpp_remove_reference_t<_Tuple0> >::value >::type,	1332	__make_index_sequence< tuple_size<__libcpp_remove_reference_t<_Tuple0> >::value >,
1313	_Tuple0,	1333	_Tuple0,
1314	_Tuples...> {};	1334	_Tuples...> {};
1315		1335
...	@@ -1317,7 +1337,7 @@ template <class _Types, class _I0, class _J0>	...	@@ -1317,7 +1337,7 @@ template <class _Types, class _I0, class _J0>
1317	struct __tuple_cat;	1337	struct __tuple_cat;
1318		1338
1319	template <class... _Types, size_t... _I0, size_t... _J0>	1339	template <class... _Types, size_t... _I0, size_t... _J0>
1320	struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> > {	1340	struct __tuple_cat<tuple<_Types...>, __index_sequence<_I0...>, __index_sequence<_J0...>> {
1321	template <class _Tuple0>	1341	template <class _Tuple0>
1322	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14	1342	_LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14
1323	typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type	1343	typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
...	@@ -1335,8 +1355,8 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J	...	@@ -1335,8 +1355,8 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
1335	using _T0 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple0>;	1355	using _T0 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple0>;
1336	using _T1 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple1>;	1356	using _T1 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple1>;
1337	return __tuple_cat<tuple<_Types..., __copy_cvref_t<_Tuple0, typename tuple_element<_J0, _T0>::type>&&...>,	1357	return __tuple_cat<tuple<_Types..., __copy_cvref_t<_Tuple0, typename tuple_element<_J0, _T0>::type>&&...>,
1338	typename __make_tuple_indices<sizeof...(_Types) + tuple_size<_T0>::value>::type,	1358	__make_index_sequence<sizeof...(_Types) + tuple_size<_T0>::value>,
1339	typename __make_tuple_indices<tuple_size<_T1>::value>::type>()(	1359	__make_index_sequence<tuple_size<_T1>::value>>()(
1340	std::forward_as_tuple(	1360	std::forward_as_tuple(
1341	std::forward<_Types>(std::get<_I0>(__t))..., std::get<_J0>(std::forward<_Tuple0>(__t0))...),	1361	std::forward<_Types>(std::get<_I0>(__t))..., std::get<_J0>(std::forward<_Tuple0>(__t0))...),
1342	std::forward<_Tuple1>(__t1),	1362	std::forward<_Tuple1>(__t1),
...	@@ -1346,21 +1366,21 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J	...	@@ -1346,21 +1366,21 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
1346		1366
1347	template <class _TupleDst, class _TupleSrc, size_t... _Indices>	1367	template <class _TupleDst, class _TupleSrc, size_t... _Indices>
1348	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _TupleDst	1368	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 _TupleDst
1349	__tuple_cat_select_element_wise(_TupleSrc&& __src, __tuple_indices<_Indices...>) {	1369	__tuple_cat_select_element_wise(_TupleSrc&& __src, __index_sequence<_Indices...>) {
1350	static_assert(tuple_size<_TupleDst>::value == tuple_size<_TupleSrc>::value,	1370	static_assert(tuple_size<_TupleDst>::value == tuple_size<_TupleSrc>::value,
1351	"misuse of __tuple_cat_select_element_wise with tuples of different sizes");	1371	"misuse of __tuple_cat_select_element_wise with tuples of different sizes");
1352	return _TupleDst(std::get<_Indices>(std::forward<_TupleSrc>(__src))...);	1372	return _TupleDst(std::get<_Indices>(std::forward<_TupleSrc>(__src))...);
1353	}	1373	}
1354		1374
1355	template <class _Tuple0, class... _Tuples>	1375	template <class _Tuple0, class... _Tuples>
1356	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 typename __tuple_cat_return<_Tuple0, _Tuples...>::type	1376	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX14 __tuple_cat_return_t<_Tuple0, _Tuples...>
1357	tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) {	1377	tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls) {
1358	using _T0 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple0>;	1378	using _T0 _LIBCPP_NODEBUG = __libcpp_remove_reference_t<_Tuple0>;
1359	using _TRet _LIBCPP_NODEBUG = typename __tuple_cat_return<_Tuple0, _Tuples...>::type;	1379	using _TRet _LIBCPP_NODEBUG = __tuple_cat_return_t<_Tuple0, _Tuples...>;
1360	using _T0Indices _LIBCPP_NODEBUG = typename __make_tuple_indices<tuple_size<_T0>::value>::type;	1380	using _T0Indices _LIBCPP_NODEBUG = __make_index_sequence<tuple_size<_T0>::value>;
1361	using _TRetIndices _LIBCPP_NODEBUG = typename __make_tuple_indices<tuple_size<_TRet>::value>::type;	1381	using _TRetIndices _LIBCPP_NODEBUG = __make_index_sequence<tuple_size<_TRet>::value>;
1362	return std::__tuple_cat_select_element_wise<_TRet>(	1382	return std::__tuple_cat_select_element_wise<_TRet>(
1363	__tuple_cat<tuple<>, __tuple_indices<>, _T0Indices>()(	1383	__tuple_cat<tuple<>, __index_sequence<>, _T0Indices>()(
1364	tuple<>(), std::forward<_Tuple0>(__t0), std::forward<_Tuples>(__tpls)...),	1384	tuple<>(), std::forward<_Tuple0>(__t0), std::forward<_Tuples>(__tpls)...),
1365	_TRetIndices());	1385	_TRetIndices());
1366	}	1386	}
...	@@ -1376,7 +1396,7 @@ struct uses_allocator<tuple<_Tp...>, _Alloc> : true_type {};	...	@@ -1376,7 +1396,7 @@ struct uses_allocator<tuple<_Tp...>, _Alloc> : true_type {};
1376	// clang-format off	1396	// clang-format off
1377	template <class _Fn, class _Tuple, size_t... _Id>	1397	template <class _Fn, class _Tuple, size_t... _Id>
1378	inline _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto)	1398	inline _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto)
1379	__apply_tuple_impl(_Fn&& __f, _Tuple&& __t, __tuple_indices<_Id...>)	1399	__apply_tuple_impl(_Fn&& __f, _Tuple&& __t, index_sequence<_Id...>)
1380	_LIBCPP_NOEXCEPT_RETURN(std::__invoke(std::forward<_Fn>(__f), std::get<_Id>(std::forward<_Tuple>(__t))...))	1400	_LIBCPP_NOEXCEPT_RETURN(std::__invoke(std::forward<_Fn>(__f), std::get<_Id>(std::forward<_Tuple>(__t))...))
1381		1401
1382	template <class _Fn, class _Tuple>	1402	template <class _Fn, class _Tuple>
...	@@ -1384,28 +1404,29 @@ inline _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) apply(_Fn&& __f, _Tuple&&	...	@@ -1384,28 +1404,29 @@ inline _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) apply(_Fn&& __f, _Tuple&&
1384	_LIBCPP_NOEXCEPT_RETURN(std::__apply_tuple_impl(	1404	_LIBCPP_NOEXCEPT_RETURN(std::__apply_tuple_impl(
1385	std::forward<_Fn>(__f),	1405	std::forward<_Fn>(__f),
1386	std::forward<_Tuple>(__t),	1406	std::forward<_Tuple>(__t),
1387	typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{}))	1407	make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>()))
1388		1408
1389	#if _LIBCPP_STD_VER >= 20	1409	#if _LIBCPP_STD_VER >= 20
1390	template <class _Tp, class _Tuple, size_t... _Idx>	1410	template <class _Tp, class _Tuple, size_t... _Idx>
1391	inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>)	1411	inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>)
1392	noexcept(noexcept(_Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...)))	1412	noexcept(noexcept(_Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...)))
1393	requires is_constructible_v<_Tp, decltype(std::get<_Idx>(std::forward<_Tuple>(__t)))...> {	1413	requires is_constructible_v<_Tp, decltype(std::get<_Idx>(std::forward<_Tuple>(__t)))...> {
1394	return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...);	1414	return _Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...);
1395	}	1415	}
1396	#else	1416	#else
1397	template <class _Tp, class _Tuple, size_t... _Idx>	1417	template <class _Tp, class _Tuple, size_t... _Idx>
1398	inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, __tuple_indices<_Idx...>,	1418	inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp __make_from_tuple_impl(_Tuple&& __t, index_sequence<_Idx...>,
1399	enable_if_t<is_constructible_v<_Tp, decltype(std::get<_Idx>(std::forward<_Tuple>(__t)))...>> * = nullptr)	1419	enable_if_t<is_constructible_v<_Tp, decltype(std::get<_Idx>(std::forward<_Tuple>(__t)))...>> * = nullptr)
1400	_LIBCPP_NOEXCEPT_RETURN(_Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...))	1420	_LIBCPP_NOEXCEPT_RETURN(_Tp(std::get<_Idx>(std::forward<_Tuple>(__t))...))
1401	#endif // _LIBCPP_STD_VER >= 20	1421	#endif // _LIBCPP_STD_VER >= 20
		1422	#undef _LIBCPP_NOEXCEPT_RETURN
1402		1423
1403	template <class _Tp, class _Tuple,	1424	template <class _Tp, class _Tuple,
1404	class _Seq = typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type, class = void>	1425	class _Seq = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>, class = void>
1405	inline constexpr bool __can_make_from_tuple = false;	1426	inline constexpr bool __can_make_from_tuple = false;
1406		1427
1407	template <class _Tp, class _Tuple, size_t... _Idx>	1428	template <class _Tp, class _Tuple, size_t... _Idx>
1408	inline constexpr bool __can_make_from_tuple<_Tp, _Tuple, __tuple_indices<_Idx...>,	1429	inline constexpr bool __can_make_from_tuple<_Tp, _Tuple, index_sequence<_Idx...>,
1409	enable_if_t<is_constructible_v<_Tp, decltype(std::get<_Idx>(std::declval<_Tuple>()))...>>> = true;	1430	enable_if_t<is_constructible_v<_Tp, decltype(std::get<_Idx>(std::declval<_Tuple>()))...>>> = true;
1410		1431
1411	// Based on LWG3528(https://wg21.link/LWG3528) and http://eel.is/c++draft/description#structure.requirements-9,	1432	// Based on LWG3528(https://wg21.link/LWG3528) and http://eel.is/c++draft/description#structure.requirements-9,
...	@@ -1418,10 +1439,19 @@ template <class _Tp, class _Tuple>	...	@@ -1418,10 +1439,19 @@ template <class _Tp, class _Tuple>
1418	#else	1439	#else
1419	template <class _Tp, class _Tuple, class = enable_if_t<__can_make_from_tuple<_Tp, _Tuple>>> // strengthen	1440	template <class _Tp, class _Tuple, class = enable_if_t<__can_make_from_tuple<_Tp, _Tuple>>> // strengthen
1420	#endif // _LIBCPP_STD_VER >= 20	1441	#endif // _LIBCPP_STD_VER >= 20
1421	inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp make_from_tuple(_Tuple&& __t)	1442
1422	_LIBCPP_NOEXCEPT_RETURN(std::__make_from_tuple_impl<_Tp>(	1443	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI constexpr _Tp make_from_tuple(_Tuple&& __t)
1423	std::forward<_Tuple>(__t), typename __make_tuple_indices<tuple_size_v<remove_reference_t<_Tuple>>>::type{}))	1444	noexcept(noexcept(std::__make_from_tuple_impl<_Tp>(std::forward<_Tuple>(__t),
1424	# undef _LIBCPP_NOEXCEPT_RETURN	1445	make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>()))) {
		1446	#if _LIBCPP_STD_VER >= 23
		1447	if constexpr (tuple_size_v<remove_reference_t<_Tuple>> == 1) {
		1448	static_assert(!std::reference_constructs_from_temporary_v<_Tp, decltype(std::get<0>(std::declval<_Tuple>()))>,
		1449	"Attempted construction of reference element binds to a temporary whose lifetime has ended");
		1450	}
		1451	#endif // _LIBCPP_STD_VER >= 23
		1452	return std::__make_from_tuple_impl<_Tp>(
		1453	std::forward<_Tuple>(__t), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>());
		1454	}
1425		1455
1426	# endif // _LIBCPP_STD_VER >= 17	1456	# endif // _LIBCPP_STD_VER >= 17
1427		1457

lib/libcxx/include/type_traits+8-2

 @@ -454,6 +454,10 @@ namespace std
       template<class B> inline constexpr bool negation_v
         = negation<B>::value;                                   // since C++17
+      // [meta.const.eval], constant evaluation context
+      constexpr bool is_constant_evaluated() noexcept;                   // C++20
+      template<class T>
+        consteval bool is_within_lifetime(const T*) noexcept;            // C++26
 }
 */
 @@ -546,9 +550,7 @@ namespace std
 #  if _LIBCPP_STD_VER >= 20
 #    include <__type_traits/common_reference.h>
-#    include <__type_traits/is_bounded_array.h>
 #    include <__type_traits/is_constant_evaluated.h>
-#    include <__type_traits/is_unbounded_array.h>
 #    include <__type_traits/type_identity.h>
 #    include <__type_traits/unwrap_ref.h>
 #  endif
 @@ -559,6 +561,10 @@ namespace std
 #    include <__type_traits/reference_converts_from_temporary.h>
 #  endif
+#  if _LIBCPP_STD_VER >= 26
+#    include <__type_traits/is_within_lifetime.h>
+#  endif
 #  include <version>
 #  if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)

lib/libcxx/include/typeindex+5-3

...	@@ -86,8 +86,8 @@ public:	...	@@ -86,8 +86,8 @@ public:
86	}	86	}
87	# endif	87	# endif
88		88
89	_LIBCPP_HIDE_FROM_ABI size_t hash_code() const _NOEXCEPT { return __t_->hash_code(); }	89	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t hash_code() const _NOEXCEPT { return __t_->hash_code(); }
90	_LIBCPP_HIDE_FROM_ABI const char* name() const _NOEXCEPT { return __t_->name(); }	90	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const char* name() const _NOEXCEPT { return __t_->name(); }
91	};	91	};
92		92
93	template <class _Tp>	93	template <class _Tp>
...	@@ -95,7 +95,9 @@ struct hash;	...	@@ -95,7 +95,9 @@ struct hash;
95		95
96	template <>	96	template <>
97	struct hash<type_index> : public __unary_function<type_index, size_t> {	97	struct hash<type_index> : public __unary_function<type_index, size_t> {
98	_LIBCPP_HIDE_FROM_ABI size_t operator()(type_index __index) const _NOEXCEPT { return __index.hash_code(); }	98	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t operator()(type_index __index) const _NOEXCEPT {
		99	return __index.hash_code();
		100	}
99	};	101	};
100		102
101	_LIBCPP_END_NAMESPACE_STD	103	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/include/typeinfo+92-89

 @@ -95,11 +95,13 @@ class _LIBCPP_EXPORTED_FROM_ABI type_info {
 public:
   virtual ~type_info();
-  const char* name() const _NOEXCEPT;
+  [[__nodiscard__]] const char* name() const _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI bool before(const type_info& __arg) const _NOEXCEPT { return __compare(__arg) < 0; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool before(const type_info& __arg) const _NOEXCEPT {
+    return __compare(__arg) < 0;
+  }
-  size_t hash_code() const _NOEXCEPT;
+  [[__nodiscard__]] size_t hash_code() const _NOEXCEPT;
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const type_info& __arg) const _NOEXCEPT {
     // When evaluated in a constant expression, both type infos simply can't come
 @@ -186,99 +188,99 @@ public:
 #        endif
 #      endif
-struct __type_info_implementations {
+namespace __type_info_implementations {
-  struct __string_impl_base {
+struct __string_impl_base {
-    typedef const char* __type_name_t;
+  typedef const char* __type_name_t;
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR static const char*
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR static const char*
-    __type_name_to_string(__type_name_t __v) _NOEXCEPT {
+  __type_name_to_string(__type_name_t __v) _NOEXCEPT {
-      return __v;
+    return __v;
-    }
+  }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR static __type_name_t
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE _LIBCPP_CONSTEXPR static __type_name_t
-    __string_to_type_name(const char* __v) _NOEXCEPT {
+  __string_to_type_name(const char* __v) _NOEXCEPT {
-      return __v;
+    return __v;
-    }
+  }
-  };
+};
-  struct __unique_impl : __string_impl_base {
+struct __unique_impl : __string_impl_base {
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __v) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __v) _NOEXCEPT {
-      return reinterpret_cast<size_t>(__v);
+    return reinterpret_cast<size_t>(__v);
-    }
+  }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
-      return __lhs == __rhs;
+    return __lhs == __rhs;
-    }
+  }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
-      return __lhs < __rhs;
+    return __lhs < __rhs;
-    }
+  }
-  };
+};
-  struct __non_unique_impl : __string_impl_base {
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __ptr) _NOEXCEPT {
-      size_t __hash = 5381;
-      while (unsigned char __c = static_cast<unsigned char>(*__ptr++))
-        __hash = (__hash * 33) ^ __c;
-      return __hash;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
-      return __lhs == __rhs || __builtin_strcmp(__lhs, __rhs) == 0;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
-      return __builtin_strcmp(__lhs, __rhs) < 0;
-    }
-  };
-  struct __non_unique_arm_rtti_bit_impl {
+struct __non_unique_impl : __string_impl_base {
-    typedef uintptr_t __type_name_t;
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __ptr) _NOEXCEPT {
+    size_t __hash = 5381;
+    while (unsigned char __c = static_cast<unsigned char>(*__ptr++))
+      __hash = (__hash * 33) ^ __c;
+    return __hash;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    return __lhs == __rhs || __builtin_strcmp(__lhs, __rhs) == 0;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    return __builtin_strcmp(__lhs, __rhs) < 0;
+  }
+};
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
+struct __non_unique_arm_rtti_bit_impl {
-      return reinterpret_cast<const char*>(__v & ~__non_unique_rtti_bit::value);
+  typedef uintptr_t __type_name_t;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
-      return reinterpret_cast<__type_name_t>(__v);
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __v) _NOEXCEPT {
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static const char* __type_name_to_string(__type_name_t __v) _NOEXCEPT {
-      if (__is_type_name_unique(__v))
+    return reinterpret_cast<const char*>(__v & ~__non_unique_rtti_bit::value);
-        return __v;
+  }
-      return __non_unique_impl::__hash(__type_name_to_string(__v));
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static __type_name_t __string_to_type_name(const char* __v) _NOEXCEPT {
-    }
+    return reinterpret_cast<__type_name_t>(__v);
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+  }
-      if (__lhs == __rhs)
-        return true;
-      if (__is_type_name_unique(__lhs) || __is_type_name_unique(__rhs))
-        // Either both are unique and have a different address, or one of them
-        // is unique and the other one isn't. In both cases they are unequal.
-        return false;
-      return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) == 0;
-    }
-    _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
-      if (__is_type_name_unique(__lhs) || __is_type_name_unique(__rhs))
-        return __lhs < __rhs;
-      return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) < 0;
-    }
-  private:
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static size_t __hash(__type_name_t __v) _NOEXCEPT {
-    // The unique bit is the top bit. It is expected that __type_name_t is 64 bits when
+    if (__is_type_name_unique(__v))
-    // this implementation is actually used.
+      return __v;
-    typedef integral_constant<__type_name_t, (1ULL << ((__CHAR_BIT__ * sizeof(__type_name_t)) - 1))>
+    return __non_unique_impl::__hash(__type_name_to_string(__v));
-        __non_unique_rtti_bit;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __eq(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    if (__lhs == __rhs)
+      return true;
+    if (__is_type_name_unique(__lhs) || __is_type_name_unique(__rhs))
+      // Either both are unique and have a different address, or one of them
+      // is unique and the other one isn't. In both cases they are unequal.
+      return false;
+    return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) == 0;
+  }
+  _LIBCPP_HIDE_FROM_ABI _LIBCPP_ALWAYS_INLINE static bool __lt(__type_name_t __lhs, __type_name_t __rhs) _NOEXCEPT {
+    if (__is_type_name_unique(__lhs) || __is_type_name_unique(__rhs))
+      return __lhs < __rhs;
+    return __builtin_strcmp(__type_name_to_string(__lhs), __type_name_to_string(__rhs)) < 0;
+  }
-    _LIBCPP_HIDE_FROM_ABI static bool __is_type_name_unique(__type_name_t __lhs) _NOEXCEPT {
+private:
-      return !(__lhs & __non_unique_rtti_bit::value);
+  // The unique bit is the top bit. It is expected that __type_name_t is 64 bits when
-    }
+  // this implementation is actually used.
-  };
+  typedef integral_constant<__type_name_t, (1ULL << ((__CHAR_BIT__ * sizeof(__type_name_t)) - 1))>
+      __non_unique_rtti_bit;
+  _LIBCPP_HIDE_FROM_ABI static bool __is_type_name_unique(__type_name_t __lhs) _NOEXCEPT {
+    return !(__lhs & __non_unique_rtti_bit::value);
+  }
+};
-  typedef
+typedef
 #      if _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 1
-      __unique_impl
+    __unique_impl
 #      elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 2
-      __non_unique_impl
+    __non_unique_impl
 #      elif _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION == 3
-      __non_unique_arm_rtti_bit_impl
+    __non_unique_arm_rtti_bit_impl
 #      else
 #        error invalid configuration for _LIBCPP_TYPEINFO_COMPARISON_IMPLEMENTATION
 #      endif
-          __impl;
+        __impl;
-};
+} // namespace __type_info_implementations
 #      if __has_cpp_attribute(_Clang::__ptrauth_vtable_pointer__)
 #        if __has_feature(ptrauth_type_info_vtable_pointer_discrimination)
 @@ -306,14 +308,15 @@ protected:
 public:
   virtual ~type_info();
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const char* name() const _NOEXCEPT {
+    return __impl::__type_name_to_string(__type_name);
+  }
-  _LIBCPP_HIDE_FROM_ABI const char* name() const _NOEXCEPT { return __impl::__type_name_to_string(__type_name); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool before(const type_info& __arg) const _NOEXCEPT {
-  _LIBCPP_HIDE_FROM_ABI bool before(const type_info& __arg) const _NOEXCEPT {
     return __impl::__lt(__type_name, __arg.__type_name);
   }
-  _LIBCPP_HIDE_FROM_ABI size_t hash_code() const _NOEXCEPT { return __impl::__hash(__type_name); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t hash_code() const _NOEXCEPT { return __impl::__hash(__type_name); }
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX23 bool operator==(const type_info& __arg) const _NOEXCEPT {
     // When evaluated in a constant expression, both type infos simply can't come
 @@ -336,7 +339,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bad_cast(const bad_cast&) _NOEXCEPT            = default;
   _LIBCPP_HIDE_FROM_ABI bad_cast& operator=(const bad_cast&) _NOEXCEPT = default;
   ~bad_cast() _NOEXCEPT override;
-  const char* what() const _NOEXCEPT override;
+  [[__nodiscard__]] const char* what() const _NOEXCEPT override;
 };
 class _LIBCPP_EXPORTED_FROM_ABI bad_typeid : public exception {
 @@ -345,7 +348,7 @@ public:
   _LIBCPP_HIDE_FROM_ABI bad_typeid(const bad_typeid&) _NOEXCEPT            = default;
   _LIBCPP_HIDE_FROM_ABI bad_typeid& operator=(const bad_typeid&) _NOEXCEPT = default;
   ~bad_typeid() _NOEXCEPT override;
-  const char* what() const _NOEXCEPT override;
+  [[__nodiscard__]] const char* what() const _NOEXCEPT override;
 };
 } // namespace std

lib/libcxx/include/unordered_map+179-304

 @@ -600,6 +600,7 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #  include <__memory/addressof.h>
 #  include <__memory/allocator.h>
 #  include <__memory/allocator_traits.h>
+#  include <__memory/compressed_pair.h>
 #  include <__memory/pointer_traits.h>
 #  include <__memory/unique_ptr.h>
 #  include <__memory_resource/polymorphic_allocator.h>
 @@ -643,34 +644,9 @@ _LIBCPP_PUSH_MACROS
 _LIBCPP_BEGIN_NAMESPACE_STD
-template <class _Key,
-          class _Cp,
-          class _Hash,
-          class _Pred,
-          bool = is_empty<_Hash>::value && !__libcpp_is_final<_Hash>::value>
-class __unordered_map_hasher : private _Hash {
-public:
-  _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher() _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value) : _Hash() {}
-  _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher(const _Hash& __h) _NOEXCEPT_(is_nothrow_copy_constructible<_Hash>::value)
-      : _Hash(__h) {}
-  _LIBCPP_HIDE_FROM_ABI const _Hash& hash_function() const _NOEXCEPT { return *this; }
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Cp& __x) const { return static_cast<const _Hash&>(*this)(__x.first); }
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _Key& __x) const { return static_cast<const _Hash&>(*this)(__x); }
-#  if _LIBCPP_STD_VER >= 20
-  template <typename _K2>
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const _K2& __x) const {
-    return static_cast<const _Hash&>(*this)(__x);
-  }
-#  endif
-  _LIBCPP_HIDE_FROM_ABI void swap(__unordered_map_hasher& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Hash>) {
-    using std::swap;
-    swap(static_cast<_Hash&>(*this), static_cast<_Hash&>(__y));
-  }
-};
 template <class _Key, class _Cp, class _Hash, class _Pred>
-class __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, false> {
+class __unordered_map_hasher {
-  _Hash __hash_;
+  _LIBCPP_COMPRESSED_ELEMENT(_Hash, __hash_);
 public:
   _LIBCPP_HIDE_FROM_ABI __unordered_map_hasher() _NOEXCEPT_(is_nothrow_default_constructible<_Hash>::value)
 @@ -692,60 +668,16 @@ public:
   }
 };
-template <class _Key, class _Cp, class _Hash, class _Pred, bool __b>
+template <class _Key, class _Cp, class _Hash, class _Pred>
 inline _LIBCPP_HIDE_FROM_ABI void
-swap(__unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __x,
+swap(__unordered_map_hasher<_Key, _Cp, _Hash, _Pred>& __x, __unordered_map_hasher<_Key, _Cp, _Hash, _Pred>& __y)
-     __unordered_map_hasher<_Key, _Cp, _Hash, _Pred, __b>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
+    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
   __x.swap(__y);
 }
-template <class _Key,
-          class _Cp,
-          class _Pred,
-          class _Hash,
-          bool = is_empty<_Pred>::value && !__libcpp_is_final<_Pred>::value>
-class __unordered_map_equal : private _Pred {
-public:
-  _LIBCPP_HIDE_FROM_ABI __unordered_map_equal() _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value) : _Pred() {}
-  _LIBCPP_HIDE_FROM_ABI __unordered_map_equal(const _Pred& __p) _NOEXCEPT_(is_nothrow_copy_constructible<_Pred>::value)
-      : _Pred(__p) {}
-  _LIBCPP_HIDE_FROM_ABI const _Pred& key_eq() const _NOEXCEPT { return *this; }
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _Cp& __y) const {
-    return static_cast<const _Pred&>(*this)(__x.first, __y.first);
-  }
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _Key& __y) const {
-    return static_cast<const _Pred&>(*this)(__x.first, __y);
-  }
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _Cp& __y) const {
-    return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);
-  }
-#  if _LIBCPP_STD_VER >= 20
-  template <typename _K2>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Cp& __x, const _K2& __y) const {
-    return static_cast<const _Pred&>(*this)(__x.first, __y);
-  }
-  template <typename _K2>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _Cp& __y) const {
-    return static_cast<const _Pred&>(*this)(__x, __y.__get_value().first);
-  }
-  template <typename _K2>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _Key& __x, const _K2& __y) const {
-    return static_cast<const _Pred&>(*this)(__x, __y);
-  }
-  template <typename _K2>
-  _LIBCPP_HIDE_FROM_ABI bool operator()(const _K2& __x, const _Key& __y) const {
-    return static_cast<const _Pred&>(*this)(__x, __y);
-  }
-#  endif
-  _LIBCPP_HIDE_FROM_ABI void swap(__unordered_map_equal& __y) _NOEXCEPT_(__is_nothrow_swappable_v<_Pred>) {
-    using std::swap;
-    swap(static_cast<_Pred&>(*this), static_cast<_Pred&>(__y));
-  }
-};
 template <class _Key, class _Cp, class _Pred, class _Hash>
-class __unordered_map_equal<_Key, _Cp, _Pred, _Hash, false> {
+class __unordered_map_equal {
-  _Pred __pred_;
+  _LIBCPP_COMPRESSED_ELEMENT(_Pred, __pred_);
 public:
   _LIBCPP_HIDE_FROM_ABI __unordered_map_equal() _NOEXCEPT_(is_nothrow_default_constructible<_Pred>::value)
 @@ -780,9 +712,9 @@ public:
   }
 };
-template <class _Key, class _Cp, class _Pred, class _Hash, bool __b>
+template <class _Key, class _Cp, class _Pred, class _Hash>
 inline _LIBCPP_HIDE_FROM_ABI void
-swap(__unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __x, __unordered_map_equal<_Key, _Cp, _Pred, _Hash, __b>& __y)
+swap(__unordered_map_equal<_Key, _Cp, _Pred, _Hash>& __x, __unordered_map_equal<_Key, _Cp, _Pred, _Hash>& __y)
     _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))) {
   __x.swap(__y);
 }
 @@ -844,10 +776,10 @@ class __hash_map_iterator {
 public:
   typedef forward_iterator_tag iterator_category;
-  typedef typename _NodeTypes::__map_value_type value_type;
+  using value_type      = typename _HashIterator::value_type;
-  typedef typename _NodeTypes::difference_type difference_type;
+  using difference_type = ptrdiff_t;
   typedef value_type& reference;
-  typedef typename _NodeTypes::__map_value_type_pointer pointer;
+  using pointer = typename _HashIterator::pointer;
   _LIBCPP_HIDE_FROM_ABI __hash_map_iterator() _NOEXCEPT {}
 @@ -895,10 +827,10 @@ class __hash_map_const_iterator {
 public:
   typedef forward_iterator_tag iterator_category;
-  typedef typename _NodeTypes::__map_value_type value_type;
+  using value_type      = typename _HashIterator::value_type;
-  typedef typename _NodeTypes::difference_type difference_type;
+  using difference_type = ptrdiff_t;
   typedef const value_type& reference;
-  typedef typename _NodeTypes::__const_map_value_type_pointer pointer;
+  using pointer = typename _HashIterator::pointer;
   _LIBCPP_HIDE_FROM_ABI __hash_map_const_iterator() _NOEXCEPT {}
 @@ -972,9 +904,6 @@ private:
   __table __table_;
-  typedef typename __table::_NodeTypes _NodeTypes;
-  typedef typename __table::__node_pointer __node_pointer;
-  typedef typename __table::__node_const_pointer __node_const_pointer;
   typedef typename __table::__node_traits __node_traits;
   typedef typename __table::__node_allocator __node_allocator;
   typedef typename __table::__node __node;
 @@ -1046,10 +975,10 @@ public:
 #  endif
   _LIBCPP_HIDE_FROM_ABI explicit unordered_map(const allocator_type& __a);
-  _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u) = default;
   _LIBCPP_HIDE_FROM_ABI unordered_map(const unordered_map& __u, const allocator_type& __a);
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u) = default;
   _LIBCPP_HIDE_FROM_ABI unordered_map(unordered_map&& __u, const allocator_type& __a);
   _LIBCPP_HIDE_FROM_ABI unordered_map(initializer_list<value_type> __il);
   _LIBCPP_HIDE_FROM_ABI
 @@ -1099,41 +1028,26 @@ public:
     static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
   }
-  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(const unordered_map& __u) {
+  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(const unordered_map& __u) = default;
-#  ifndef _LIBCPP_CXX03_LANG
-    __table_ = __u.__table_;
-#  else
-    if (this != std::addressof(__u)) {
-      __table_.clear();
-      __table_.hash_function()   = __u.__table_.hash_function();
-      __table_.key_eq()          = __u.__table_.key_eq();
-      __table_.max_load_factor() = __u.__table_.max_load_factor();
-      __table_.__copy_assign_alloc(__u.__table_);
-      insert(__u.begin(), __u.end());
-    }
-#  endif
-    return *this;
-  }
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(unordered_map&& __u)
+  _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(unordered_map&& __u) = default;
-      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
   _LIBCPP_HIDE_FROM_ABI unordered_map& operator=(initializer_list<value_type> __il);
 #  endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
     return allocator_type(__table_.__node_alloc());
   }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
-  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
   _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert(const value_type& __x) { return __table_.__emplace_unique(__x); }
 @@ -1187,14 +1101,13 @@ public:
 #  if _LIBCPP_STD_VER >= 17
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(const key_type& __k, _Args&&... __args) {
-    return __table_.__emplace_unique_key_args(
+    return __table_.__emplace_unique(
-        __k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple(std::forward<_Args>(__args)...));
+        piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple(std::forward<_Args>(__args)...));
   }
   template <class... _Args>
   _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> try_emplace(key_type&& __k, _Args&&... __args) {
-    return __table_.__emplace_unique_key_args(
+    return __table_.__emplace_unique(
-        __k,
         piecewise_construct,
         std::forward_as_tuple(std::move(__k)),
         std::forward_as_tuple(std::forward<_Args>(__args)...));
 @@ -1212,7 +1125,7 @@ public:
   template <class _Vp>
   _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(const key_type& __k, _Vp&& __v) {
-    pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k, __k, std::forward<_Vp>(__v));
+    pair<iterator, bool> __res = __table_.__emplace_unique(__k, std::forward<_Vp>(__v));
     if (!__res.second) {
       __res.first->second = std::forward<_Vp>(__v);
     }
 @@ -1221,7 +1134,7 @@ public:
   template <class _Vp>
   _LIBCPP_HIDE_FROM_ABI pair<iterator, bool> insert_or_assign(key_type&& __k, _Vp&& __v) {
-    pair<iterator, bool> __res = __table_.__emplace_unique_key_args(__k, std::move(__k), std::forward<_Vp>(__v));
+    pair<iterator, bool> __res = __table_.__emplace_unique(std::move(__k), std::forward<_Vp>(__v));
     if (!__res.second) {
       __res.first->second = std::forward<_Vp>(__v);
     }
 @@ -1258,10 +1171,10 @@ public:
                                         "node_type with incompatible allocator passed to unordered_map::insert()");
     return __table_.template __node_handle_insert_unique<node_type>(__hint.__i_, std::move(__nh));
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
     return __table_.template __node_handle_extract<node_type>(__key);
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
     return __table_.template __node_handle_extract<node_type>(__it.__i_);
   }
 @@ -1295,52 +1208,56 @@ public:
     __table_.swap(__u.__table_);
   }
-  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function().hash_function(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI hasher hash_function() const {
-  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
+    return __table_.hash_function().hash_function();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
     return __table_.find(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
     return __table_.find(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
+    return __table_.__count_unique(__k);
+  }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
     return __table_.__count_unique(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
 #  if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
     return find(__k) != end();
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
     return __table_.__equal_range_unique(__k);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
     return __table_.__equal_range_unique(__k);
   }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
     return __table_.__equal_range_unique(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
     return __table_.__equal_range_unique(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
 @@ -1350,24 +1267,32 @@ public:
   _LIBCPP_HIDE_FROM_ABI mapped_type& operator[](key_type&& __k);
 #  endif
-  _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mapped_type& at(const key_type& __k);
-  _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const mapped_type& at(const key_type& __k) const;
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT {
+    return __table_.max_bucket_count();
+  }
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
+    return __table_.bucket_size(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+    return __table_.cbegin(__n);
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const {
+    return __table_.cbegin(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
-  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
-  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
   _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
   _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_unique(__n); }
   _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_unique(__n); }
 @@ -1384,10 +1309,10 @@ template <class _InputIterator,
           class _Pred      = equal_to<__iter_key_type<_InputIterator>>,
           class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(_InputIterator,
               _InputIterator,
               typename allocator_traits<_Allocator>::size_type = 0,
 @@ -1401,10 +1326,10 @@ template <ranges::input_range _Range,
           class _Hash      = hash<__range_key_type<_Range>>,
           class _Pred      = equal_to<__range_key_type<_Range>>,
           class _Allocator = allocator<__range_to_alloc_type<_Range>>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(from_range_t,
               _Range&&,
               typename allocator_traits<_Allocator>::size_type = 0,
 @@ -1419,10 +1344,10 @@ template <class _Key,
           class _Hash      = hash<remove_const_t<_Key>>,
           class _Pred      = equal_to<remove_const_t<_Key>>,
           class _Allocator = allocator<pair<const _Key, _Tp>>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(initializer_list<pair<_Key, _Tp>>,
               typename allocator_traits<_Allocator>::size_type = 0,
               _Hash                                            = _Hash(),
 @@ -1432,7 +1357,7 @@ unordered_map(initializer_list<pair<_Key, _Tp>>,
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_map<__iter_key_type<_InputIterator>,
                      __iter_mapped_type<_InputIterator>,
 @@ -1443,7 +1368,7 @@ unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocat
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(_InputIterator, _InputIterator, _Allocator)
     -> unordered_map<__iter_key_type<_InputIterator>,
                      __iter_mapped_type<_InputIterator>,
 @@ -1455,9 +1380,9 @@ template <class _InputIterator,
           class _Hash,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_map<__iter_key_type<_InputIterator>,
                      __iter_mapped_type<_InputIterator>,
 @@ -1467,7 +1392,7 @@ unordered_map(_InputIterator, _InputIterator, typename allocator_traits<_Allocat
 #    if _LIBCPP_STD_VER >= 23
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_map<__range_key_type<_Range>,
                      __range_mapped_type<_Range>,
 @@ -1475,7 +1400,7 @@ unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::siz
                      equal_to<__range_key_type<_Range>>,
                      _Allocator>;
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(from_range_t, _Range&&, _Allocator)
     -> unordered_map<__range_key_type<_Range>,
                      __range_mapped_type<_Range>,
 @@ -1486,9 +1411,9 @@ unordered_map(from_range_t, _Range&&, _Allocator)
 template <ranges::input_range _Range,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_map<__range_key_type<_Range>,
                      __range_mapped_type<_Range>,
 @@ -1498,11 +1423,11 @@ unordered_map(from_range_t, _Range&&, typename allocator_traits<_Allocator>::siz
 #    endif
-template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_map<remove_const_t<_Key>, _Tp, hash<remove_const_t<_Key>>, equal_to<remove_const_t<_Key>>, _Allocator>;
-template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, _Allocator)
     -> unordered_map<remove_const_t<_Key>, _Tp, hash<remove_const_t<_Key>>, equal_to<remove_const_t<_Key>>, _Allocator>;
 @@ -1510,9 +1435,9 @@ template <class _Key,
           class _Tp,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_map(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_map<remove_const_t<_Key>, _Tp, _Hash, equal_to<remove_const_t<_Key>>, _Allocator>;
 #  endif
 @@ -1563,12 +1488,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
   insert(__first, __last);
 }
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(const unordered_map& __u) : __table_(__u.__table_) {
-  __table_.__rehash_unique(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(const unordered_map& __u, const allocator_type& __a)
     : __table_(__u.__table_, typename __table::allocator_type(__a)) {
 @@ -1578,11 +1497,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(const unordered_ma
 #  ifndef _LIBCPP_CXX03_LANG
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(unordered_map&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(std::move(__u.__table_)) {}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(unordered_map&& __u, const allocator_type& __a)
     : __table_(std::move(__u.__table_), typename __table::allocator_type(__a)) {
 @@ -1618,14 +1532,6 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
   insert(__il.begin(), __il.end());
 }
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
-unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
-  __table_ = std::move(__u.__table_);
-  return *this;
-}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 inline unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
 @@ -1646,16 +1552,13 @@ inline void unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::insert(_InputIterato
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 _Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](const key_type& __k) {
-  return __table_
+  return __table_.__emplace_unique(piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple())
-      .__emplace_unique_key_args(__k, piecewise_construct, std::forward_as_tuple(__k), std::forward_as_tuple())
       .first->second;
 }
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 _Tp& unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k) {
-  return __table_
+  return __table_.__emplace_unique(piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple())
-      .__emplace_unique_key_args(
-          __k, piecewise_construct, std::forward_as_tuple(std::move(__k)), std::forward_as_tuple())
       .first->second;
 }
 #  else // _LIBCPP_CXX03_LANG
 @@ -1781,12 +1684,8 @@ private:
   __table __table_;
-  typedef typename __table::_NodeTypes _NodeTypes;
   typedef typename __table::__node_traits __node_traits;
-  typedef typename __table::__node_allocator __node_allocator;
   typedef typename __table::__node __node;
-  typedef __hash_map_node_destructor<__node_allocator> _Dp;
-  typedef unique_ptr<__node, _Dp> __node_holder;
   typedef allocator_traits<allocator_type> __alloc_traits;
   static_assert(is_same<typename __node_traits::size_type, typename __alloc_traits::size_type>::value,
                 "Allocator uses different size_type for different types");
 @@ -1852,11 +1751,10 @@ public:
 #  endif
   _LIBCPP_HIDE_FROM_ABI explicit unordered_multimap(const allocator_type& __a);
-  _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u) = default;
   _LIBCPP_HIDE_FROM_ABI unordered_multimap(const unordered_multimap& __u, const allocator_type& __a);
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_multimap(unordered_multimap&& __u)
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap(unordered_multimap&& __u) = default;
-      _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
   _LIBCPP_HIDE_FROM_ABI unordered_multimap(unordered_multimap&& __u, const allocator_type& __a);
   _LIBCPP_HIDE_FROM_ABI unordered_multimap(initializer_list<value_type> __il);
   _LIBCPP_HIDE_FROM_ABI unordered_multimap(
 @@ -1906,41 +1804,26 @@ public:
     static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Key, _Hash, _Pred>(0)), "");
   }
-  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(const unordered_multimap& __u) {
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(const unordered_multimap& __u) = default;
-#  ifndef _LIBCPP_CXX03_LANG
-    __table_ = __u.__table_;
-#  else
-    if (this != std::addressof(__u)) {
-      __table_.clear();
-      __table_.hash_function()   = __u.__table_.hash_function();
-      __table_.key_eq()          = __u.__table_.key_eq();
-      __table_.max_load_factor() = __u.__table_.max_load_factor();
-      __table_.__copy_assign_alloc(__u.__table_);
-      insert(__u.begin(), __u.end());
-    }
-#  endif
-    return *this;
-  }
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(unordered_multimap&& __u)
+  _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(unordered_multimap&& __u) = default;
-      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
   _LIBCPP_HIDE_FROM_ABI unordered_multimap& operator=(initializer_list<value_type> __il);
 #  endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
     return allocator_type(__table_.__node_alloc());
   }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
-  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
   _LIBCPP_HIDE_FROM_ABI iterator insert(const value_type& __x) { return __table_.__emplace_multi(__x); }
 @@ -2008,10 +1891,10 @@ public:
                                         "node_type with incompatible allocator passed to unordered_multimap::insert()");
     return __table_.template __node_handle_insert_multi<node_type>(__hint.__i_, std::move(__nh));
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
     return __table_.template __node_handle_extract<node_type>(__key);
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
     return __table_.template __node_handle_extract<node_type>(__it.__i_);
   }
 @@ -2045,71 +1928,83 @@ public:
     __table_.swap(__u.__table_);
   }
-  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function().hash_function(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI hasher hash_function() const {
-  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
+    return __table_.hash_function().hash_function();
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq().key_eq(); }
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
     return __table_.find(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
     return __table_.find(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
+    return __table_.__count_multi(__k);
+  }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
     return __table_.__count_multi(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
 #  if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
     return find(__k) != end();
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
     return __table_.__equal_range_multi(__k);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
     return __table_.__equal_range_multi(__k);
   }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
     return __table_.__equal_range_multi(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
     return __table_.__equal_range_multi(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT {
+    return __table_.max_bucket_count();
+  }
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
+    return __table_.bucket_size(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+    return __table_.cbegin(__n);
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const {
+    return __table_.cbegin(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
-  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
-  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
   _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
   _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_multi(__n); }
   _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_multi(__n); }
 @@ -2121,10 +2016,10 @@ template <class _InputIterator,
           class _Pred      = equal_to<__iter_key_type<_InputIterator>>,
           class _Allocator = allocator<__iter_to_alloc_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(_InputIterator,
                    _InputIterator,
                    typename allocator_traits<_Allocator>::size_type = 0,
 @@ -2142,10 +2037,10 @@ template <ranges::input_range _Range,
           class _Hash      = hash<__range_key_type<_Range>>,
           class _Pred      = equal_to<__range_key_type<_Range>>,
           class _Allocator = allocator<__range_to_alloc_type<_Range>>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(from_range_t,
                    _Range&&,
                    typename allocator_traits<_Allocator>::size_type = 0,
 @@ -2160,21 +2055,21 @@ template <class _Key,
           class _Hash      = hash<remove_const_t<_Key>>,
           class _Pred      = equal_to<remove_const_t<_Key>>,
           class _Allocator = allocator<pair<const _Key, _Tp>>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
-unordered_multimap(
+unordered_multimap(initializer_list<pair<_Key, _Tp>>,
-    initializer_list<pair<_Key, _Tp>>,
+                   typename allocator_traits<_Allocator>::size_type = 0,
-    typename allocator_traits<_Allocator>::size_type = 0,
+                   _Hash                                            = _Hash(),
-    _Hash                                            = _Hash(),
+                   _Pred                                            = _Pred(),
-    _Pred                                            = _Pred(),
+                   _Allocator                                       = _Allocator())
-    _Allocator = _Allocator()) -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
+    -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, _Pred, _Allocator>;
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_multimap<__iter_key_type<_InputIterator>,
                           __iter_mapped_type<_InputIterator>,
 @@ -2185,7 +2080,7 @@ unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Al
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(_InputIterator, _InputIterator, _Allocator)
     -> unordered_multimap<__iter_key_type<_InputIterator>,
                           __iter_mapped_type<_InputIterator>,
 @@ -2197,9 +2092,9 @@ template <class _InputIterator,
           class _Hash,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_multimap<__iter_key_type<_InputIterator>,
                           __iter_mapped_type<_InputIterator>,
 @@ -2209,7 +2104,7 @@ unordered_multimap(_InputIterator, _InputIterator, typename allocator_traits<_Al
 #    if _LIBCPP_STD_VER >= 23
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_multimap<__range_key_type<_Range>,
                           __range_mapped_type<_Range>,
 @@ -2217,7 +2112,7 @@ unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>
                           equal_to<__range_key_type<_Range>>,
                           _Allocator>;
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(from_range_t, _Range&&, _Allocator)
     -> unordered_multimap<__range_key_type<_Range>,
                           __range_mapped_type<_Range>,
 @@ -2228,9 +2123,9 @@ unordered_multimap(from_range_t, _Range&&, _Allocator)
 template <ranges::input_range _Range,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_multimap<__range_key_type<_Range>,
                           __range_mapped_type<_Range>,
 @@ -2240,7 +2135,7 @@ unordered_multimap(from_range_t, _Range&&, typename allocator_traits<_Allocator>
 #    endif
-template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_multimap<remove_const_t<_Key>,
                           _Tp,
 @@ -2248,7 +2143,7 @@ unordered_multimap(initializer_list<pair<_Key, _Tp>>, typename allocator_traits<
                           equal_to<remove_const_t<_Key>>,
                           _Allocator>;
-template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Key, class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(initializer_list<pair<_Key, _Tp>>, _Allocator)
     -> unordered_multimap<remove_const_t<_Key>,
                           _Tp,
 @@ -2260,9 +2155,9 @@ template <class _Key,
           class _Tp,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multimap(
     initializer_list<pair<_Key, _Tp>>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_multimap<remove_const_t<_Key>, _Tp, _Hash, equal_to<remove_const_t<_Key>>, _Allocator>;
 @@ -2315,13 +2210,6 @@ template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(const allocator_type& __a)
     : __table_(typename __table::allocator_type(__a)) {}
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(const unordered_multimap& __u)
-    : __table_(__u.__table_) {
-  __table_.__rehash_multi(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
     const unordered_multimap& __u, const allocator_type& __a)
 @@ -2332,11 +2220,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
 #  ifndef _LIBCPP_CXX03_LANG
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(unordered_multimap&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(std::move(__u.__table_)) {}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
     unordered_multimap&& __u, const allocator_type& __a)
 @@ -2373,14 +2256,6 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
   insert(__il.begin(), __il.end());
 }
-template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
-inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
-unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
-  __table_ = std::move(__u.__table_);
-  return *this;
-}
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 inline unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {

lib/libcxx/include/unordered_set+168-195

 @@ -544,8 +544,6 @@ template <class Value, class Hash, class Pred, class Alloc>
 #  include <__iterator/distance.h>
 #  include <__iterator/erase_if_container.h>
 #  include <__iterator/iterator_traits.h>
-#  include <__iterator/ranges_iterator_traits.h>
-#  include <__memory/addressof.h>
 #  include <__memory/allocator.h>
 #  include <__memory/allocator_traits.h>
 #  include <__memory_resource/polymorphic_allocator.h>
 @@ -558,7 +556,6 @@ template <class Value, class Hash, class Pred, class Alloc>
 #  include <__type_traits/invoke.h>
 #  include <__type_traits/is_allocator.h>
 #  include <__type_traits/is_integral.h>
-#  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_swappable.h>
 @@ -703,10 +700,10 @@ public:
 #  endif
   _LIBCPP_HIDE_FROM_ABI explicit unordered_set(const allocator_type& __a);
-  _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u) = default;
   _LIBCPP_HIDE_FROM_ABI unordered_set(const unordered_set& __u, const allocator_type& __a);
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+  _LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u) = default;
   _LIBCPP_HIDE_FROM_ABI unordered_set(unordered_set&& __u, const allocator_type& __a);
   _LIBCPP_HIDE_FROM_ABI unordered_set(initializer_list<value_type> __il);
   _LIBCPP_HIDE_FROM_ABI
 @@ -733,30 +730,26 @@ public:
     static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
   }
-  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(const unordered_set& __u) {
+  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(const unordered_set& __u) = default;
-    __table_ = __u.__table_;
-    return *this;
-  }
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(unordered_set&& __u)
+  _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(unordered_set&& __u) = default;
-      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
   _LIBCPP_HIDE_FROM_ABI unordered_set& operator=(initializer_list<value_type> __il);
 #  endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
     return allocator_type(__table_.__node_alloc());
   }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
-  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
 #  ifndef _LIBCPP_CXX03_LANG
   template <class... _Args>
 @@ -808,10 +801,10 @@ public:
                                         "node_type with incompatible allocator passed to unordered_set::insert()");
     return __table_.template __node_handle_insert_unique<node_type>(__h, std::move(__nh));
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
     return __table_.template __node_handle_extract<node_type>(__key);
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __it) {
     return __table_.template __node_handle_extract<node_type>(__it);
   }
 @@ -845,71 +838,81 @@ public:
     __table_.swap(__u.__table_);
   }
-  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
-  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
     return __table_.find(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
     return __table_.find(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_unique(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
+    return __table_.__count_unique(__k);
+  }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
     return __table_.__count_unique(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
 #  if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
     return find(__k) != end();
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
     return __table_.__equal_range_unique(__k);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
     return __table_.__equal_range_unique(__k);
   }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
     return __table_.__equal_range_unique(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
     return __table_.__equal_range_unique(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT {
+    return __table_.max_bucket_count();
+  }
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
+    return __table_.bucket_size(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+    return __table_.cbegin(__n);
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const {
+    return __table_.cbegin(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
-  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
-  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
   _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
   _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_unique(__n); }
   _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_unique(__n); }
 @@ -917,47 +920,48 @@ public:
 #  if _LIBCPP_STD_VER >= 17
 template <class _InputIterator,
-          class _Hash      = hash<__iter_value_type<_InputIterator>>,
+          class _Hash      = hash<__iterator_value_type<_InputIterator>>,
-          class _Pred      = equal_to<__iter_value_type<_InputIterator>>,
+          class _Pred      = equal_to<__iterator_value_type<_InputIterator>>,
-          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iterator_value_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(_InputIterator,
               _InputIterator,
               typename allocator_traits<_Allocator>::size_type = 0,
               _Hash                                            = _Hash(),
               _Pred                                            = _Pred(),
-              _Allocator = _Allocator()) -> unordered_set<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+              _Allocator                                       = _Allocator())
+    -> unordered_set<__iterator_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Hash      = hash<ranges::range_value_t<_Range>>,
           class _Pred      = equal_to<ranges::range_value_t<_Range>>,
           class _Allocator = allocator<ranges::range_value_t<_Range>>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
-unordered_set(
+unordered_set(from_range_t,
-    from_range_t,
+              _Range&&,
-    _Range&&,
+              typename allocator_traits<_Allocator>::size_type = 0,
-    typename allocator_traits<_Allocator>::size_type = 0,
+              _Hash                                            = _Hash(),
-    _Hash                                            = _Hash(),
+              _Pred                                            = _Pred(),
-    _Pred                                            = _Pred(),
+              _Allocator                                       = _Allocator())
-    _Allocator = _Allocator()) -> unordered_set<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
+    -> unordered_set<ranges::range_value_t<_Range>, _Hash, _Pred, _Allocator>; // C++23
 #    endif
 template <class _Tp,
           class _Hash      = hash<_Tp>,
           class _Pred      = equal_to<_Tp>,
           class _Allocator = allocator<_Tp>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(initializer_list<_Tp>,
               typename allocator_traits<_Allocator>::size_type = 0,
               _Hash                                            = _Hash(),
 @@ -967,33 +971,36 @@ unordered_set(initializer_list<_Tp>,
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
-    -> unordered_set<__iter_value_type<_InputIterator>,
+    -> unordered_set<__iterator_value_type<_InputIterator>,
-                     hash<__iter_value_type<_InputIterator>>,
+                     hash<__iterator_value_type<_InputIterator>>,
-                     equal_to<__iter_value_type<_InputIterator>>,
+                     equal_to<__iterator_value_type<_InputIterator>>,
                      _Allocator>;
 template <class _InputIterator,
           class _Hash,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-    -> unordered_set<__iter_value_type<_InputIterator>, _Hash, equal_to<__iter_value_type<_InputIterator>>, _Allocator>;
+    -> unordered_set<__iterator_value_type<_InputIterator>,
+                     _Hash,
+                     equal_to<__iterator_value_type<_InputIterator>>,
+                     _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_set<ranges::range_value_t<_Range>,
                      hash<ranges::range_value_t<_Range>>,
                      equal_to<ranges::range_value_t<_Range>>,
                      _Allocator>;
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(from_range_t, _Range&&, _Allocator)
     -> unordered_set<ranges::range_value_t<_Range>,
                      hash<ranges::range_value_t<_Range>>,
 @@ -1003,24 +1010,24 @@ unordered_set(from_range_t, _Range&&, _Allocator)
 template <ranges::input_range _Range,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_set<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
 #    endif
-template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_set<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
 template <class _Tp,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_set(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_set<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
 #  endif
 @@ -1070,12 +1077,6 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const allocator_type& __a) : __table_(__a) {}
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set& __u) : __table_(__u.__table_) {
-  __table_.__rehash_unique(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set& __u, const allocator_type& __a)
     : __table_(__u.__table_, __a) {
 @@ -1085,11 +1086,6 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(const unordered_set&
 #  ifndef _LIBCPP_CXX03_LANG
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(std::move(__u.__table_)) {}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(unordered_set&& __u, const allocator_type& __a)
     : __table_(std::move(__u.__table_), __a) {
 @@ -1125,14 +1121,6 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
   insert(__il.begin(), __il.end());
 }
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline unordered_set<_Value, _Hash, _Pred, _Alloc>&
-unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
-  __table_ = std::move(__u.__table_);
-  return *this;
-}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {
 @@ -1308,11 +1296,10 @@ public:
 #  endif
   _LIBCPP_HIDE_FROM_ABI explicit unordered_multiset(const allocator_type& __a);
-  _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u);
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u) = default;
   _LIBCPP_HIDE_FROM_ABI unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u)
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u) = default;
-      _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
   _LIBCPP_HIDE_FROM_ABI unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
   _LIBCPP_HIDE_FROM_ABI unordered_multiset(initializer_list<value_type> __il);
   _LIBCPP_HIDE_FROM_ABI unordered_multiset(
 @@ -1339,30 +1326,26 @@ public:
     static_assert(sizeof(std::__diagnose_unordered_container_requirements<_Value, _Hash, _Pred>(0)), "");
   }
-  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(const unordered_multiset& __u) {
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(const unordered_multiset& __u) = default;
-    __table_ = __u.__table_;
-    return *this;
-  }
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(unordered_multiset&& __u)
+  _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(unordered_multiset&& __u) = default;
-      _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
   _LIBCPP_HIDE_FROM_ABI unordered_multiset& operator=(initializer_list<value_type> __il);
 #  endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI allocator_type get_allocator() const _NOEXCEPT {
     return allocator_type(__table_.__node_alloc());
   }
   [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool empty() const _NOEXCEPT { return __table_.size() == 0; }
-  _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type size() const _NOEXCEPT { return __table_.size(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_size() const _NOEXCEPT { return __table_.max_size(); }
-  _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator begin() _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator end() _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator begin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator end() const _NOEXCEPT { return __table_.end(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cbegin() const _NOEXCEPT { return __table_.begin(); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator cend() const _NOEXCEPT { return __table_.end(); }
 #  ifndef _LIBCPP_CXX03_LANG
   template <class... _Args>
 @@ -1410,10 +1393,10 @@ public:
                                         "node_type with incompatible allocator passed to unordered_multiset::insert()");
     return __table_.template __node_handle_insert_multi<node_type>(__hint, std::move(__nh));
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __position) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(const_iterator __position) {
     return __table_.template __node_handle_extract<node_type>(__position);
   }
-  _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI node_type extract(key_type const& __key) {
     return __table_.template __node_handle_extract<node_type>(__key);
   }
 @@ -1454,71 +1437,81 @@ public:
     __table_.swap(__u.__table_);
   }
-  _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI hasher hash_function() const { return __table_.hash_function(); }
-  _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI key_equal key_eq() const { return __table_.key_eq(); }
-  _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const key_type& __k) { return __table_.find(__k); }
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const key_type& __k) const { return __table_.find(__k); }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iterator find(const _K2& __k) {
     return __table_.find(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_iterator find(const _K2& __k) const {
     return __table_.find(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const { return __table_.__count_multi(__k); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const key_type& __k) const {
+    return __table_.__count_multi(__k);
+  }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type count(const _K2& __k) const {
     return __table_.__count_multi(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
 #  if _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const key_type& __k) const { return find(__k) != end(); }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool contains(const _K2& __k) const {
     return find(__k) != end();
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const key_type& __k) {
     return __table_.__equal_range_multi(__k);
   }
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {
     return __table_.__equal_range_multi(__k);
   }
 #  if _LIBCPP_STD_VER >= 20
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<iterator, iterator> equal_range(const _K2& __k) {
     return __table_.__equal_range_multi(__k);
   }
   template <class _K2, enable_if_t<__is_transparent_v<hasher, _K2> && __is_transparent_v<key_equal, _K2>>* = nullptr>
-  _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI pair<const_iterator, const_iterator> equal_range(const _K2& __k) const {
     return __table_.__equal_range_multi(__k);
   }
 #  endif // _LIBCPP_STD_VER >= 20
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_count() const _NOEXCEPT { return __table_.bucket_count(); }
-  _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT { return __table_.max_bucket_count(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type max_bucket_count() const _NOEXCEPT {
+    return __table_.max_bucket_count();
+  }
-  _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const { return __table_.bucket_size(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket_size(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
+    return __table_.bucket_size(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_type bucket(const key_type& __k) const { return __table_.bucket(__k); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator begin(size_type __n) { return __table_.begin(__n); }
-  _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI local_iterator end(size_type __n) { return __table_.end(__n); }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const { return __table_.cbegin(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator begin(size_type __n) const {
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+    return __table_.cbegin(__n);
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const { return __table_.cbegin(__n); }
+  }
-  _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator end(size_type __n) const { return __table_.cend(__n); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cbegin(size_type __n) const {
+    return __table_.cbegin(__n);
+  }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const_local_iterator cend(size_type __n) const { return __table_.cend(__n); }
-  _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float load_factor() const _NOEXCEPT { return __table_.load_factor(); }
-  _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI float max_load_factor() const _NOEXCEPT { return __table_.max_load_factor(); }
   _LIBCPP_HIDE_FROM_ABI void max_load_factor(float __mlf) { __table_.max_load_factor(__mlf); }
   _LIBCPP_HIDE_FROM_ABI void rehash(size_type __n) { __table_.__rehash_multi(__n); }
   _LIBCPP_HIDE_FROM_ABI void reserve(size_type __n) { __table_.__reserve_multi(__n); }
 @@ -1526,31 +1519,31 @@ public:
 #  if _LIBCPP_STD_VER >= 17
 template <class _InputIterator,
-          class _Hash      = hash<__iter_value_type<_InputIterator>>,
+          class _Hash      = hash<__iterator_value_type<_InputIterator>>,
-          class _Pred      = equal_to<__iter_value_type<_InputIterator>>,
+          class _Pred      = equal_to<__iterator_value_type<_InputIterator>>,
-          class _Allocator = allocator<__iter_value_type<_InputIterator>>,
+          class _Allocator = allocator<__iterator_value_type<_InputIterator>>,
           class            = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(
     _InputIterator,
     _InputIterator,
     typename allocator_traits<_Allocator>::size_type = 0,
     _Hash                                            = _Hash(),
     _Pred                                            = _Pred(),
-    _Allocator = _Allocator()) -> unordered_multiset<__iter_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
+    _Allocator = _Allocator()) -> unordered_multiset<__iterator_value_type<_InputIterator>, _Hash, _Pred, _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
 template <ranges::input_range _Range,
           class _Hash      = hash<ranges::range_value_t<_Range>>,
           class _Pred      = equal_to<ranges::range_value_t<_Range>>,
           class _Allocator = allocator<ranges::range_value_t<_Range>>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(
     from_range_t,
     _Range&&,
 @@ -1564,10 +1557,10 @@ template <class _Tp,
           class _Hash      = hash<_Tp>,
           class _Pred      = equal_to<_Tp>,
           class _Allocator = allocator<_Tp>,
-          class            = enable_if_t<!__is_allocator<_Hash>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Hash>>,
           class            = enable_if_t<!is_integral<_Hash>::value>,
-          class            = enable_if_t<!__is_allocator<_Pred>::value>,
+          class            = enable_if_t<!__is_allocator_v<_Pred>>,
-          class            = enable_if_t<__is_allocator<_Allocator>::value>>
+          class            = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(initializer_list<_Tp>,
                    typename allocator_traits<_Allocator>::size_type = 0,
                    _Hash                                            = _Hash(),
 @@ -1577,36 +1570,36 @@ unordered_multiset(initializer_list<_Tp>,
 template <class _InputIterator,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Allocator)
-    -> unordered_multiset<__iter_value_type<_InputIterator>,
+    -> unordered_multiset<__iterator_value_type<_InputIterator>,
-                          hash<__iter_value_type<_InputIterator>>,
+                          hash<__iterator_value_type<_InputIterator>>,
-                          equal_to<__iter_value_type<_InputIterator>>,
+                          equal_to<__iterator_value_type<_InputIterator>>,
                           _Allocator>;
 template <class _InputIterator,
           class _Hash,
           class _Allocator,
           class = enable_if_t<__has_input_iterator_category<_InputIterator>::value>,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(_InputIterator, _InputIterator, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
-    -> unordered_multiset<__iter_value_type<_InputIterator>,
+    -> unordered_multiset<__iterator_value_type<_InputIterator>,
                           _Hash,
-                          equal_to<__iter_value_type<_InputIterator>>,
+                          equal_to<__iterator_value_type<_InputIterator>>,
                           _Allocator>;
 #    if _LIBCPP_STD_VER >= 23
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_multiset<ranges::range_value_t<_Range>,
                           hash<ranges::range_value_t<_Range>>,
                           equal_to<ranges::range_value_t<_Range>>,
                           _Allocator>;
-template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <ranges::input_range _Range, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(from_range_t, _Range&&, _Allocator)
     -> unordered_multiset<ranges::range_value_t<_Range>,
                           hash<ranges::range_value_t<_Range>>,
 @@ -1616,24 +1609,24 @@ unordered_multiset(from_range_t, _Range&&, _Allocator)
 template <ranges::input_range _Range,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(from_range_t, _Range&&, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_multiset<ranges::range_value_t<_Range>, _Hash, equal_to<ranges::range_value_t<_Range>>, _Allocator>;
 #    endif
-template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator<_Allocator>::value>>
+template <class _Tp, class _Allocator, class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Allocator)
     -> unordered_multiset<_Tp, hash<_Tp>, equal_to<_Tp>, _Allocator>;
 template <class _Tp,
           class _Hash,
           class _Allocator,
-          class = enable_if_t<!__is_allocator<_Hash>::value>,
+          class = enable_if_t<!__is_allocator_v<_Hash>>,
           class = enable_if_t<!is_integral<_Hash>::value>,
-          class = enable_if_t<__is_allocator<_Allocator>::value>>
+          class = enable_if_t<__is_allocator_v<_Allocator>>>
 unordered_multiset(initializer_list<_Tp>, typename allocator_traits<_Allocator>::size_type, _Hash, _Allocator)
     -> unordered_multiset<_Tp, _Hash, equal_to<_Tp>, _Allocator>;
 #  endif
 @@ -1685,13 +1678,6 @@ template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(const allocator_type& __a)
     : __table_(__a) {}
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(const unordered_multiset& __u)
-    : __table_(__u.__table_) {
-  __table_.__rehash_multi(__u.bucket_count());
-  insert(__u.begin(), __u.end());
-}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
     const unordered_multiset& __u, const allocator_type& __a)
 @@ -1702,11 +1688,6 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
 #  ifndef _LIBCPP_CXX03_LANG
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(std::move(__u.__table_)) {}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
     unordered_multiset&& __u, const allocator_type& __a)
 @@ -1743,14 +1724,6 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
   insert(__il.begin(), __il.end());
 }
-template <class _Value, class _Hash, class _Pred, class _Alloc>
-inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
-unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value) {
-  __table_ = std::move(__u.__table_);
-  return *this;
-}
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(initializer_list<value_type> __il) {

lib/libcxx/include/utility+12

...	@@ -216,6 +216,18 @@ template<size_t N>	...	@@ -216,6 +216,18 @@ template<size_t N>
216	template<class... T>	216	template<class... T>
217	using index_sequence_for = make_index_sequence<sizeof...(T)>;	217	using index_sequence_for = make_index_sequence<sizeof...(T)>;
218		218
		219	template<class T, T... Values> // C++26
		220	struct tuple_size<integer_sequence<T, Values...>>;
		221
		222	template<size_t I, class T, T... Values> // C++26
		223	struct tuple_element<I, integer_sequence<T, Values...>>;
		224
		225	template<size_t I, class T, T... Values> // C++26
		226	struct tuple_element<I, const integer_sequence<T, Values...>>;
		227
		228	template<size_t I, class T, T... Values> // C++26
		229	constexpr T get(integer_sequence<T, Values...>) noexcept;
		230
219	template<class T, class U=T>	231	template<class T, class U=T>
220	constexpr T exchange(T& obj, U&& new_value) // constexpr in C++17, noexcept in C++23	232	constexpr T exchange(T& obj, U&& new_value) // constexpr in C++17, noexcept in C++23
221	noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_assignable<T&, U>::value);	233	noexcept(is_nothrow_move_constructible<T>::value && is_nothrow_assignable<T&, U>::value);

lib/libcxx/include/valarray+106-161

 @@ -362,6 +362,7 @@ template <class T> unspecified2 end(const valarray<T>& v);
 #  include <__memory/uninitialized_algorithms.h>
 #  include <__type_traits/decay.h>
 #  include <__type_traits/remove_reference.h>
+#  include <__utility/exception_guard.h>
 #  include <__utility/move.h>
 #  include <__utility/swap.h>
 #  include <cmath>
 @@ -395,9 +396,9 @@ public:
   _LIBCPP_HIDE_FROM_ABI slice(size_t __start, size_t __size, size_t __stride)
       : __start_(__start), __size_(__size), __stride_(__stride) {}
-  _LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t start() const { return __start_; }
-  _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t size() const { return __size_; }
-  _LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t stride() const { return __stride_; }
 #  if _LIBCPP_STD_VER >= 20
 @@ -792,7 +793,7 @@ private:
 public:
   // construct/destroy:
   _LIBCPP_HIDE_FROM_ABI valarray() : __begin_(nullptr), __end_(nullptr) {}
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 explicit valarray(size_t __n);
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 explicit valarray(size_t __n);
   _LIBCPP_HIDE_FROM_ABI valarray(const value_type& __x, size_t __n);
   valarray(const value_type* __p, size_t __n);
   valarray(const valarray& __v);
 @@ -804,7 +805,7 @@ public:
   valarray(const gslice_array<value_type>& __ga);
   valarray(const mask_array<value_type>& __ma);
   valarray(const indirect_array<value_type>& __ia);
-  inline _LIBCPP_HIDE_FROM_ABI_AFTER_V1 ~valarray();
+  inline _LIBCPP_HIDE_FROM_ABI_SINCE_LLVM8 ~valarray();
   // assignment:
   valarray& operator=(const valarray& __v);
 @@ -821,36 +822,41 @@ public:
   _LIBCPP_HIDE_FROM_ABI valarray& operator=(const __val_expr<_ValExpr>& __v);
   // element access:
-  _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI const value_type& operator[](size_t __i) const {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < size(), "valarray::operator[] index out of bounds");
     return __begin_[__i];
   }
-  _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) {
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type& operator[](size_t __i) {
     _LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(__i < size(), "valarray::operator[] index out of bounds");
     return __begin_[__i];
   }
   // subset operations:
-  _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __val_expr<__slice_expr<const valarray&> > operator[](slice __s) const;
-  _LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI slice_array<value_type> operator[](slice __s);
-  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const gslice& __gs) const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> >
-  _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs);
+  operator[](const gslice& __gs) const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](const gslice& __gs);
 #  ifndef _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](gslice&& __gs) const;
-  _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI gslice_array<value_type> operator[](gslice&& __gs);
 #  endif // _LIBCPP_CXX03_LANG
+  [[__nodiscard__]]
   _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](const valarray<bool>& __vb) const;
-  _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](const valarray<bool>& __vb);
 #  ifndef _LIBCPP_CXX03_LANG
+  [[__nodiscard__]]
   _LIBCPP_HIDE_FROM_ABI __val_expr<__mask_expr<const valarray&> > operator[](valarray<bool>&& __vb) const;
-  _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI mask_array<value_type> operator[](valarray<bool>&& __vb);
 #  endif // _LIBCPP_CXX03_LANG
+  [[__nodiscard__]]
   _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](const valarray<size_t>& __vs) const;
-  _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](const valarray<size_t>& __vs);
 #  ifndef _LIBCPP_CXX03_LANG
+  [[__nodiscard__]]
   _LIBCPP_HIDE_FROM_ABI __val_expr<__indirect_expr<const valarray&> > operator[](valarray<size_t>&& __vs) const;
-  _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs);
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI indirect_array<value_type> operator[](valarray<size_t>&& __vs);
 #  endif // _LIBCPP_CXX03_LANG
   // unary operators:
 @@ -904,16 +910,16 @@ public:
   // member functions:
   _LIBCPP_HIDE_FROM_ABI void swap(valarray& __v) _NOEXCEPT;
-  _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t size() const { return static_cast<size_t>(__end_ - __begin_); }
-  _LIBCPP_HIDE_FROM_ABI value_type sum() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type sum() const;
-  _LIBCPP_HIDE_FROM_ABI value_type min() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type min() const;
-  _LIBCPP_HIDE_FROM_ABI value_type max() const;
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI value_type max() const;
-  valarray shift(int __i) const;
+  [[__nodiscard__]] valarray shift(int __i) const;
-  valarray cshift(int __i) const;
+  [[__nodiscard__]] valarray cshift(int __i) const;
-  valarray apply(value_type __f(value_type)) const;
+  [[__nodiscard__]] valarray apply(value_type __f(value_type)) const;
-  valarray apply(value_type __f(const value_type&)) const;
+  [[__nodiscard__]] valarray apply(value_type __f(const value_type&)) const;
   void resize(size_t __n, value_type __x = value_type());
 private:
 @@ -1248,11 +1254,11 @@ public:
 #  endif // _LIBCPP_CXX03_LANG
-  _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI size_t start() const { return __1d_.size() ? __1d_[0] : 0; }
-  _LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI valarray<size_t> size() const { return __size_; }
-  _LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; }
+  [[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI valarray<size_t> stride() const { return __stride_; }
 private:
   void __init(size_t __start);
 @@ -1992,17 +1998,10 @@ template <class _Tp>
 inline valarray<_Tp>::valarray(size_t __n) : __begin_(nullptr), __end_(nullptr) {
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+      ::new ((void*)__end_) value_type();
-      for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type();
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2015,17 +2014,10 @@ template <class _Tp>
 valarray<_Tp>::valarray(const value_type* __p, size_t __n) : __begin_(nullptr), __end_(nullptr) {
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+      ::new ((void*)__end_) value_type(*__p);
-      for (size_t __n_left = __n; __n_left; ++__end_, ++__p, --__n_left)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(*__p);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2033,17 +2025,10 @@ template <class _Tp>
 valarray<_Tp>::valarray(const valarray& __v) : __begin_(nullptr), __end_(nullptr) {
   if (__v.size()) {
     __begin_ = __end_ = allocator<value_type>().allocate(__v.size());
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__v.size()); });
-    try {
+    for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+      ::new ((void*)__end_) value_type(*__p);
-      for (value_type* __p = __v.__begin_; __p != __v.__end_; ++__end_, ++__p)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(*__p);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__v.size());
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2059,18 +2044,11 @@ valarray<_Tp>::valarray(initializer_list<value_type> __il) : __begin_(nullptr),
   const size_t __n = __il.size();
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#    if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    size_t __n_left   = __n;
-#    endif // _LIBCPP_HAS_EXCEPTIONS
+    for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
-      size_t __n_left = __n;
+      ::new ((void*)__end_) value_type(*__p);
-      for (const value_type* __p = __il.begin(); __n_left; ++__end_, ++__p, --__n_left)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(*__p);
-#    if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#    endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2081,18 +2059,11 @@ valarray<_Tp>::valarray(const slice_array<value_type>& __sa) : __begin_(nullptr)
   const size_t __n = __sa.__size_;
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    size_t __n_left   = __n;
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
-      size_t __n_left = __n;
+      ::new ((void*)__end_) value_type(*__p);
-      for (const value_type* __p = __sa.__vp_; __n_left; ++__end_, __p += __sa.__stride_, --__n_left)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(*__p);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2101,19 +2072,12 @@ valarray<_Tp>::valarray(const gslice_array<value_type>& __ga) : __begin_(nullptr
   const size_t __n = __ga.__1d_.size();
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    typedef const size_t* _Ip;
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    const value_type* __s = __ga.__vp_;
-      typedef const size_t* _Ip;
+    for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_)
-      const value_type* __s = __ga.__vp_;
+      ::new ((void*)__end_) value_type(__s[*__i]);
-      for (_Ip __i = __ga.__1d_.__begin_, __e = __ga.__1d_.__end_; __i != __e; ++__i, ++__end_)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(__s[*__i]);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2122,19 +2086,12 @@ valarray<_Tp>::valarray(const mask_array<value_type>& __ma) : __begin_(nullptr),
   const size_t __n = __ma.__1d_.size();
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    typedef const size_t* _Ip;
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    const value_type* __s = __ma.__vp_;
-      typedef const size_t* _Ip;
+    for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_)
-      const value_type* __s = __ma.__vp_;
+      ::new ((void*)__end_) value_type(__s[*__i]);
-      for (_Ip __i = __ma.__1d_.__begin_, __e = __ma.__1d_.__end_; __i != __e; ++__i, ++__end_)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(__s[*__i]);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2143,19 +2100,12 @@ valarray<_Tp>::valarray(const indirect_array<value_type>& __ia) : __begin_(nullp
   const size_t __n = __ia.__1d_.size();
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    typedef const size_t* _Ip;
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+    const value_type* __s = __ia.__vp_;
-      typedef const size_t* _Ip;
+    for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_)
-      const value_type* __s = __ia.__vp_;
+      ::new ((void*)__end_) value_type(__s[*__i]);
-      for (_Ip __i = __ia.__1d_.__begin_, __e = __ia.__1d_.__end_; __i != __e; ++__i, ++__end_)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(__s[*__i]);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -2644,17 +2594,10 @@ void valarray<_Tp>::resize(size_t __n, value_type __x) {
   __clear(size());
   if (__n) {
     __begin_ = __end_ = allocator<value_type>().allocate(__n);
-#  if _LIBCPP_HAS_EXCEPTIONS
+    auto __guard      = std::__make_exception_guard([&] { __clear(__n); });
-    try {
+    for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
-#  endif // _LIBCPP_HAS_EXCEPTIONS
+      ::new ((void*)__end_) value_type(__x);
-      for (size_t __n_left = __n; __n_left; --__n_left, ++__end_)
+    __guard.__complete();
-        ::new ((void*)__end_) value_type(__x);
-#  if _LIBCPP_HAS_EXCEPTIONS
-    } catch (...) {
-      __clear(__n);
-      throw;
-    }
-#  endif // _LIBCPP_HAS_EXCEPTIONS
   }
 }
 @@ -3168,7 +3111,7 @@ operator>=(const typename _Expr::value_type& __x, const _Expr& __y) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__abs_expr<typename _Expr::value_type>, _Expr> >
 abs(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__abs_expr<value_type>, _Expr> _Op;
 @@ -3176,7 +3119,7 @@ abs(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__acos_expr<typename _Expr::value_type>, _Expr> >
 acos(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__acos_expr<value_type>, _Expr> _Op;
 @@ -3184,7 +3127,7 @@ acos(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__asin_expr<typename _Expr::value_type>, _Expr> >
 asin(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__asin_expr<value_type>, _Expr> _Op;
 @@ -3192,7 +3135,7 @@ asin(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__atan_expr<typename _Expr::value_type>, _Expr> >
 atan(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__atan_expr<value_type>, _Expr> _Op;
 @@ -3202,15 +3145,16 @@ atan(const _Expr& __x) {
 template <class _Expr1,
           class _Expr2,
           __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+[[__nodiscard__]] inline
-atan2(const _Expr1& __x, const _Expr2& __y) {
+    _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__atan2_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+    atan2(const _Expr1& __x, const _Expr2& __y) {
   typedef typename _Expr1::value_type value_type;
   typedef _BinaryOp<__atan2_expr<value_type>, _Expr1, _Expr2> _Op;
   return __val_expr<_Op>(_Op(__atan2_expr<value_type>(), __x, __y));
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
 atan2(const _Expr& __x, const typename _Expr::value_type& __y) {
   typedef typename _Expr::value_type value_type;
 @@ -3219,7 +3163,7 @@ atan2(const _Expr& __x, const typename _Expr::value_type& __y) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 __val_expr<_BinaryOp<__atan2_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
 atan2(const typename _Expr::value_type& __x, const _Expr& __y) {
   typedef typename _Expr::value_type value_type;
 @@ -3228,7 +3172,7 @@ atan2(const typename _Expr::value_type& __x, const _Expr& __y) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cos_expr<typename _Expr::value_type>, _Expr> >
 cos(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__cos_expr<value_type>, _Expr> _Op;
 @@ -3236,7 +3180,7 @@ cos(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__cosh_expr<typename _Expr::value_type>, _Expr> >
 cosh(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__cosh_expr<value_type>, _Expr> _Op;
 @@ -3244,7 +3188,7 @@ cosh(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__exp_expr<typename _Expr::value_type>, _Expr> >
 exp(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__exp_expr<value_type>, _Expr> _Op;
 @@ -3252,7 +3196,7 @@ exp(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log_expr<typename _Expr::value_type>, _Expr> >
 log(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__log_expr<value_type>, _Expr> _Op;
 @@ -3260,7 +3204,7 @@ log(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__log10_expr<typename _Expr::value_type>, _Expr> >
 log10(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__log10_expr<value_type>, _Expr> _Op;
 @@ -3270,15 +3214,16 @@ log10(const _Expr& __x) {
 template <class _Expr1,
           class _Expr2,
           __enable_if_t<__is_val_expr<_Expr1>::value && __is_val_expr<_Expr2>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+[[__nodiscard__]] inline
-pow(const _Expr1& __x, const _Expr2& __y) {
+    _LIBCPP_HIDE_FROM_ABI __val_expr<_BinaryOp<__pow_expr<typename _Expr1::value_type>, _Expr1, _Expr2> >
+    pow(const _Expr1& __x, const _Expr2& __y) {
   typedef typename _Expr1::value_type value_type;
   typedef _BinaryOp<__pow_expr<value_type>, _Expr1, _Expr2> _Op;
   return __val_expr<_Op>(_Op(__pow_expr<value_type>(), __x, __y));
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, _Expr, __scalar_expr<typename _Expr::value_type> > >
 pow(const _Expr& __x, const typename _Expr::value_type& __y) {
   typedef typename _Expr::value_type value_type;
 @@ -3287,7 +3232,7 @@ pow(const _Expr& __x, const typename _Expr::value_type& __y) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI
 __val_expr<_BinaryOp<__pow_expr<typename _Expr::value_type>, __scalar_expr<typename _Expr::value_type>, _Expr> >
 pow(const typename _Expr::value_type& __x, const _Expr& __y) {
   typedef typename _Expr::value_type value_type;
 @@ -3296,7 +3241,7 @@ pow(const typename _Expr::value_type& __x, const _Expr& __y) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sin_expr<typename _Expr::value_type>, _Expr> >
 sin(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__sin_expr<value_type>, _Expr> _Op;
 @@ -3304,7 +3249,7 @@ sin(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sinh_expr<typename _Expr::value_type>, _Expr> >
 sinh(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__sinh_expr<value_type>, _Expr> _Op;
 @@ -3312,7 +3257,7 @@ sinh(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__sqrt_expr<typename _Expr::value_type>, _Expr> >
 sqrt(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__sqrt_expr<value_type>, _Expr> _Op;
 @@ -3320,7 +3265,7 @@ sqrt(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tan_expr<typename _Expr::value_type>, _Expr> >
 tan(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__tan_expr<value_type>, _Expr> _Op;
 @@ -3328,7 +3273,7 @@ tan(const _Expr& __x) {
 }
 template <class _Expr, __enable_if_t<__is_val_expr<_Expr>::value, int> = 0>
-inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI __val_expr<_UnaryOp<__tanh_expr<typename _Expr::value_type>, _Expr> >
 tanh(const _Expr& __x) {
   typedef typename _Expr::value_type value_type;
   typedef _UnaryOp<__tanh_expr<value_type>, _Expr> _Op;
 @@ -3336,22 +3281,22 @@ tanh(const _Expr& __x) {
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Tp* begin(valarray<_Tp>& __v) {
   return __v.__begin_;
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI const _Tp* begin(const valarray<_Tp>& __v) {
   return __v.__begin_;
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI _Tp* end(valarray<_Tp>& __v) {
   return __v.__end_;
 }
 template <class _Tp>
-inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) {
+[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI const _Tp* end(const valarray<_Tp>& __v) {
   return __v.__end_;
 }

lib/libcxx/include/variant+25-33

 @@ -247,7 +247,6 @@ namespace std {
 #  include <__type_traits/is_nothrow_assignable.h>
 #  include <__type_traits/is_nothrow_constructible.h>
 #  include <__type_traits/is_reference.h>
-#  include <__type_traits/is_replaceable.h>
 #  include <__type_traits/is_same.h>
 #  include <__type_traits/is_swappable.h>
 #  include <__type_traits/is_trivially_assignable.h>
 @@ -289,7 +288,7 @@ _LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD
 class _LIBCPP_EXPORTED_FROM_ABI bad_variant_access : public exception {
 public:
-  const char* what() const _NOEXCEPT override;
+  [[__nodiscard__]] const char* what() const _NOEXCEPT override;
 };
 _LIBCPP_END_UNVERSIONED_NAMESPACE_STD
 @@ -918,18 +917,10 @@ protected:
   _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 void __assign_alt(__alt<_Ip, _Tp>& __a, _Arg&& __arg) {
     if (this->index() == _Ip) {
       __a.__value = std::forward<_Arg>(__arg);
+    } else if constexpr (is_nothrow_constructible_v<_Tp, _Arg> || !is_nothrow_move_constructible_v<_Tp>) {
+      this->__emplace<_Ip>(std::forward<_Arg>(__arg));
     } else {
-      struct {
+      this->__emplace<_Ip>(_Tp(std::forward<_Arg>(__arg)));
-        _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(true_type) const {
-          __this->__emplace<_Ip>(std::forward<_Arg>(__arg));
-        }
-        _LIBCPP_HIDDEN _LIBCPP_CONSTEXPR_SINCE_CXX20 void operator()(false_type) const {
-          __this->__emplace<_Ip>(_Tp(std::forward<_Arg>(__arg)));
-        }
-        __assignment* __this;
-        _Arg&& __arg;
-      } __impl{this, std::forward<_Arg>(__arg)};
-      __impl(bool_constant < is_nothrow_constructible_v<_Tp, _Arg> || !is_nothrow_move_constructible_v < _Tp >> {});
     }
   }
 @@ -1127,14 +1118,14 @@ template <class _IdxSeq>
 struct __make_overloads_imp;
 template <size_t... _Idx>
-struct __make_overloads_imp<__tuple_indices<_Idx...> > {
+struct __make_overloads_imp<index_sequence<_Idx...> > {
   template <class... _Types>
   using _Apply _LIBCPP_NODEBUG = __all_overloads<__overload<_Types, _Idx>...>;
 };
 template <class... _Types>
 using _MakeOverloads _LIBCPP_NODEBUG =
-    typename __make_overloads_imp< __make_indices_imp<sizeof...(_Types), 0> >::template _Apply<_Types...>;
+    typename __make_overloads_imp<make_index_sequence<sizeof...(_Types)>>::template _Apply<_Types...>;
 template <class _Tp, class... _Types>
 using __best_match_t _LIBCPP_NODEBUG = typename invoke_result_t<_MakeOverloads<_Types...>, _Tp, _Tp>::type;
 @@ -1172,7 +1163,6 @@ class _LIBCPP_DECLSPEC_EMPTY_BASES _LIBCPP_NO_SPECIALIZATIONS variant
 public:
   using __trivially_relocatable _LIBCPP_NODEBUG =
       conditional_t<_And<__libcpp_is_trivially_relocatable<_Types>...>::value, variant, void>;
-  using __replaceable _LIBCPP_NODEBUG = conditional_t<_And<__is_replaceable<_Types>...>::value, variant, void>;
   template <bool _Dummy                                                                               = true,
             enable_if_t<__dependent_type<is_default_constructible<__first_type>, _Dummy>::value, int> = 0>
 @@ -1284,11 +1274,11 @@ public:
     return __impl_.template __emplace<_Ip>(__il, std::forward<_Args>(__args)...);
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr bool valueless_by_exception() const noexcept {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool valueless_by_exception() const noexcept {
     return __impl_.valueless_by_exception();
   }
-  _LIBCPP_HIDE_FROM_ABI constexpr size_t index() const noexcept { return __impl_.index(); }
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr size_t index() const noexcept { return __impl_.index(); }
   template < bool _Dummy       = true,
              enable_if_t< __all<(__dependent_type<is_move_constructible<_Types>, _Dummy>::value &&
 @@ -1299,7 +1289,7 @@ public:
     __impl_.__swap(__that.__impl_);
   }
-#    if _LIBCPP_STD_VER >= 26 && _LIBCPP_HAS_EXPLICIT_THIS_PARAMETER
+#    if _LIBCPP_STD_VER >= 26
   // Helper class to implement [variant.visit]/10
   //   Constraints: The call to visit does not use an explicit template-argument-list
   //   that begins with a type template-argument.
 @@ -1331,7 +1321,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr bool __holds_alternative(const variant<_Types...
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool holds_alternative(const variant<_Types...>& __v) noexcept {
   return std::__holds_alternative<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 @@ -1345,21 +1335,23 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto&& __generic_get(_Vp&& __v) {
 }
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr variant_alternative_t<_Ip, variant<_Types...>>& get(variant<_Types...>& __v) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr variant_alternative_t<_Ip, variant<_Types...>>&
+get(variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return std::__generic_get<_Ip>(__v);
 }
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr variant_alternative_t<_Ip, variant<_Types...>>&& get(variant<_Types...>&& __v) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr variant_alternative_t<_Ip, variant<_Types...>>&&
+get(variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
   return std::__generic_get<_Ip>(std::move(__v));
 }
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr const variant_alternative_t<_Ip, variant<_Types...>>&
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const variant_alternative_t<_Ip, variant<_Types...>>&
 get(const variant<_Types...>& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
 @@ -1367,7 +1359,7 @@ get(const variant<_Types...>& __v) {
 }
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr const variant_alternative_t<_Ip, variant<_Types...>>&&
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const variant_alternative_t<_Ip, variant<_Types...>>&&
 get(const variant<_Types...>&& __v) {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
 @@ -1375,25 +1367,25 @@ get(const variant<_Types...>&& __v) {
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp& get(variant<_Types...>& __v) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp& get(variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
   return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr _Tp&& get(variant<_Types...>&& __v) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Tp&& get(variant<_Types...>&& __v) {
   static_assert(!is_void_v<_Tp>);
   return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(std::move(__v));
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr const _Tp& get(const variant<_Types...>& __v) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp& get(const variant<_Types...>& __v) {
   static_assert(!is_void_v<_Tp>);
   return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& get(const variant<_Types...>&& __v) {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Tp&& get(const variant<_Types...>&& __v) {
   static_assert(!is_void_v<_Tp>);
   return std::get<__find_exactly_one_t<_Tp, _Types...>::value>(std::move(__v));
 }
 @@ -1405,7 +1397,7 @@ _LIBCPP_HIDE_FROM_ABI constexpr auto* __generic_get_if(_Vp* __v) noexcept {
 }
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
 @@ -1413,7 +1405,7 @@ get_if(variant<_Types...>* __v) noexcept {
 }
 template <size_t _Ip, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<const variant_alternative_t<_Ip, variant<_Types...>>>
 get_if(const variant<_Types...>* __v) noexcept {
   static_assert(_Ip < sizeof...(_Types));
   static_assert(!is_void_v<variant_alternative_t<_Ip, variant<_Types...>>>);
 @@ -1421,13 +1413,13 @@ get_if(const variant<_Types...>* __v) noexcept {
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> get_if(variant<_Types...>* __v) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<_Tp> get_if(variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
   return std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 template <class _Tp, class... _Types>
-_LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<const _Tp> get_if(const variant<_Types...>* __v) noexcept {
+[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr add_pointer_t<const _Tp> get_if(const variant<_Types...>* __v) noexcept {
   static_assert(!is_void_v<_Tp>);
   return std::get_if<__find_exactly_one_t<_Tp, _Types...>::value>(__v);
 }
 @@ -1608,7 +1600,7 @@ struct hash< __enable_hash_helper<variant<_Types...>, remove_const_t<_Types>...>
   using result_type _LIBCPP_DEPRECATED_IN_CXX17   = size_t;
 #    endif
-  _LIBCPP_HIDE_FROM_ABI size_t operator()(const variant<_Types...>& __v) const {
+  [[nodiscard]] _LIBCPP_HIDE_FROM_ABI size_t operator()(const variant<_Types...>& __v) const {
     using __variant_detail::__visitation::__variant;
     size_t __res =
         __v.valueless_by_exception()

lib/libcxx/include/version+41-24

 @@ -37,7 +37,8 @@ __cpp_lib_atomic_float                                  201711L <atomic>
 __cpp_lib_atomic_is_always_lock_free                    201603L <atomic>
 __cpp_lib_atomic_lock_free_type_aliases                 201907L <atomic>
 __cpp_lib_atomic_min_max                                202403L <atomic>
-__cpp_lib_atomic_ref                                    201806L <atomic>
+__cpp_lib_atomic_ref                                    202411L <atomic>
+                                                        201806L // C++20
 __cpp_lib_atomic_shared_ptr                             201711L <atomic>
 __cpp_lib_atomic_value_initialization                   201911L <atomic> <memory>
 __cpp_lib_atomic_wait                                   201907L <atomic>
 @@ -62,7 +63,7 @@ __cpp_lib_clamp                                         201603L <algorithm>
 __cpp_lib_common_reference                              202302L <type_traits>
 __cpp_lib_common_reference_wrapper                      202302L <functional>
 __cpp_lib_complex_udls                                  201309L <complex>
-__cpp_lib_concepts                                      202002L <concepts>
+__cpp_lib_concepts                                      202207L <concepts>
 __cpp_lib_constexpr_algorithms                          202306L <algorithm> <utility>
                                                         201806L // C++20
 __cpp_lib_constexpr_bitset                              202207L <bitset>
 @@ -70,6 +71,8 @@ __cpp_lib_constexpr_charconv                            202207L <charconv>
 __cpp_lib_constexpr_cmath                               202202L <cmath> <cstdlib>
 __cpp_lib_constexpr_complex                             201711L <complex>
 __cpp_lib_constexpr_dynamic_alloc                       201907L <memory>
+__cpp_lib_constexpr_flat_map                            202502L <flat_map>
+__cpp_lib_constexpr_flat_set                            202502L <flat_set>
 __cpp_lib_constexpr_forward_list                        202502L <forward_list>
 __cpp_lib_constexpr_functional                          201907L <functional>
 __cpp_lib_constexpr_iterator                            201811L <iterator>
 @@ -108,8 +111,8 @@ __cpp_lib_execution                                     201902L <execution>
                                                         201603L // C++17
 __cpp_lib_expected                                      202211L <expected>
 __cpp_lib_filesystem                                    201703L <filesystem>
-__cpp_lib_flat_map                                      202207L <flat_map>
+__cpp_lib_flat_map                                      202511L <flat_map>
-__cpp_lib_flat_set                                      202207L <flat_set>
+__cpp_lib_flat_set                                      202511L <flat_set>
 __cpp_lib_format                                        202110L <format>
 __cpp_lib_format_path                                   202403L <filesystem>
 __cpp_lib_format_ranges                                 202207L <format>
 @@ -138,7 +141,8 @@ __cpp_lib_incomplete_container_elements                 201505L <forward_list> <
 __cpp_lib_inplace_vector                                202406L <inplace_vector>
 __cpp_lib_int_pow2                                      202002L <bit>
 __cpp_lib_integer_comparison_functions                  202002L <utility>
-__cpp_lib_integer_sequence                              201304L <utility>
+__cpp_lib_integer_sequence                              202511L <utility>
+                                                        201304L // C++14
 __cpp_lib_integral_constant_callable                    201304L <type_traits>
 __cpp_lib_interpolate                                   201902L <cmath> <numeric>
 __cpp_lib_invoke                                        201411L <functional>
 @@ -184,7 +188,8 @@ __cpp_lib_nonmember_container_access                    201411L <array> <deque>
 __cpp_lib_not_fn                                        202306L <functional>
                                                         201603L // C++17
 __cpp_lib_null_iterators                                201304L <iterator>
-__cpp_lib_optional                                      202110L <optional>
+__cpp_lib_optional                                      202506L <optional>
+                                                        202110L // C++23
                                                         202106L // C++20
                                                         201606L // C++17
 __cpp_lib_optional_range_support                        202406L <optional>
 @@ -205,6 +210,7 @@ __cpp_lib_ranges_chunk_by                               202202L <ranges>
 __cpp_lib_ranges_concat                                 202403L <ranges>
 __cpp_lib_ranges_contains                               202207L <algorithm>
 __cpp_lib_ranges_find_last                              202207L <algorithm>
+__cpp_lib_ranges_indices                                202506L <ranges>
 __cpp_lib_ranges_iota                                   202202L <numeric>
 __cpp_lib_ranges_join_with                              202202L <ranges>
 __cpp_lib_ranges_repeat                                 202207L <ranges>
 @@ -245,6 +251,7 @@ __cpp_lib_starts_ends_with                              201711L <string> <string
 __cpp_lib_stdatomic_h                                   202011L <stdatomic.h>
 __cpp_lib_string_contains                               202011L <string> <string_view>
 __cpp_lib_string_resize_and_overwrite                   202110L <string>
+__cpp_lib_string_subview                                202506L <string> <string_view>
 __cpp_lib_string_udls                                   201304L <string>
 __cpp_lib_string_view                                   202403L <string> <string_view>
                                                         201803L // C++20
 @@ -333,13 +340,11 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_clamp                                201603L
 # define __cpp_lib_enable_shared_from_this              201603L
 // # define __cpp_lib_execution                            201603L
-# if _LIBCPP_HAS_FILESYSTEM && _LIBCPP_AVAILABILITY_HAS_FILESYSTEM_LIBRARY
+# if _LIBCPP_HAS_FILESYSTEM
 #   define __cpp_lib_filesystem                         201703L
 # endif
 # define __cpp_lib_gcd_lcm                              201606L
-# if defined(__GCC_DESTRUCTIVE_SIZE) && defined(__GCC_CONSTRUCTIVE_SIZE)
+# define __cpp_lib_hardware_interference_size           201703L
-#   define __cpp_lib_hardware_interference_size         201703L
-# endif
 # define __cpp_lib_has_unique_object_representations    201606L
 # define __cpp_lib_hypot                                201603L
 # define __cpp_lib_incomplete_container_elements        201505L
 @@ -391,10 +396,8 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_atomic_ref                           201806L
 // # define __cpp_lib_atomic_shared_ptr                    201711L
 # define __cpp_lib_atomic_value_initialization          201911L
-# if _LIBCPP_AVAILABILITY_HAS_SYNC
+# define __cpp_lib_atomic_wait                          201907L
-#   define __cpp_lib_atomic_wait                        201907L
+# if _LIBCPP_HAS_THREADS
-# endif
-# if _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC
 #   define __cpp_lib_barrier                            201907L
 # endif
 # define __cpp_lib_bind_front                           201907L
 @@ -406,7 +409,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # endif
 # define __cpp_lib_common_reference                     202302L
 # define __cpp_lib_common_reference_wrapper             202302L
-# define __cpp_lib_concepts                             202002L
+# define __cpp_lib_concepts                             202207L
 # define __cpp_lib_constexpr_algorithms                 201806L
 # define __cpp_lib_constexpr_complex                    201711L
 # define __cpp_lib_constexpr_dynamic_alloc              201907L
 @@ -439,10 +442,10 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_is_layout_compatible                 201907L
 # define __cpp_lib_is_nothrow_convertible               201806L
 // # define __cpp_lib_is_pointer_interconvertible          201907L
-# if _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC
+# if _LIBCPP_HAS_THREADS
 #   define __cpp_lib_jthread                            201911L
 # endif
-# if _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC
+# if _LIBCPP_HAS_THREADS
 #   define __cpp_lib_latch                              201907L
 # endif
 # define __cpp_lib_list_remove_return_type              201806L
 @@ -455,7 +458,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # endif
 # define __cpp_lib_ranges                               202110L
 # define __cpp_lib_remove_cvref                         201711L
-# if _LIBCPP_HAS_THREADS && _LIBCPP_AVAILABILITY_HAS_SYNC
+# if _LIBCPP_HAS_THREADS
 #   define __cpp_lib_semaphore                          201907L
 # endif
 # undef  __cpp_lib_shared_ptr_arrays
 @@ -494,8 +497,8 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_constexpr_typeinfo                   202106L
 # define __cpp_lib_containers_ranges                    202202L
 # define __cpp_lib_expected                             202211L
-# define __cpp_lib_flat_map                             202207L
+# define __cpp_lib_flat_map                             202511L
-# define __cpp_lib_flat_set                             202207L
+# define __cpp_lib_flat_set                             202511L
 # define __cpp_lib_format_ranges                        202207L
 // # define __cpp_lib_formatters                           202302L
 # define __cpp_lib_forward_like                         202207L
 @@ -528,7 +531,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_ranges_slide                         202202L
 # define __cpp_lib_ranges_starts_ends_with              202106L
 # define __cpp_lib_ranges_to_container                  202202L
-// # define __cpp_lib_ranges_zip                           202110L
+# define __cpp_lib_ranges_zip                           202110L
 // # define __cpp_lib_reference_from_temporary             202202L
 // # define __cpp_lib_spanstream                           202106L
 // # define __cpp_lib_stacktrace                           202011L
 @@ -544,18 +547,22 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_aligned_accessor                     202411L
 // # define __cpp_lib_associative_heterogeneous_insertion  202306L
 // # define __cpp_lib_atomic_min_max                       202403L
+# undef  __cpp_lib_atomic_ref
+# define __cpp_lib_atomic_ref                           202411L
 # undef  __cpp_lib_bind_front
 # define __cpp_lib_bind_front                           202306L
 # define __cpp_lib_bitset                               202306L
 # undef  __cpp_lib_constexpr_algorithms
 # define __cpp_lib_constexpr_algorithms                 202306L
+# define __cpp_lib_constexpr_flat_map                   202502L
+# define __cpp_lib_constexpr_flat_set                   202502L
 # define __cpp_lib_constexpr_forward_list               202502L
 # define __cpp_lib_constexpr_list                       202502L
 # if !defined(_LIBCPP_ABI_VCRUNTIME)
 #   define __cpp_lib_constexpr_new                      202406L
 # endif
 # define __cpp_lib_constexpr_queue                      202502L
-// # define __cpp_lib_constrained_equality                 202411L
+# define __cpp_lib_constrained_equality                 202411L
 // # define __cpp_lib_copyable_function                    202306L
 // # define __cpp_lib_debugging                            202311L
 // # define __cpp_lib_default_template_type_for_algorithm_values 202403L
 @@ -575,21 +582,30 @@ __cpp_lib_void_t                                        201411L <type_traits>
 // # define __cpp_lib_generate_random                      202403L
 // # define __cpp_lib_hazard_pointer                       202306L
 // # define __cpp_lib_inplace_vector                       202406L
+# undef  __cpp_lib_integer_sequence
+# define __cpp_lib_integer_sequence                     202511L
 # define __cpp_lib_is_sufficiently_aligned              202411L
 # if __has_builtin(__builtin_is_virtual_base_of)
 #   define __cpp_lib_is_virtual_base_of                 202406L
 # endif
-// # define __cpp_lib_is_within_lifetime                   202306L
+# if __has_builtin(__builtin_is_within_lifetime)
+#   define __cpp_lib_is_within_lifetime                 202306L
+# endif
 // # define __cpp_lib_linalg                               202311L
 # undef  __cpp_lib_mdspan
 # define __cpp_lib_mdspan                               202406L
 # undef  __cpp_lib_not_fn
 # define __cpp_lib_not_fn                               202306L
-// # define __cpp_lib_optional_range_support               202406L
+# undef  __cpp_lib_optional
+# define __cpp_lib_optional                             202506L
+# if _LIBCPP_HAS_EXPERIMENTAL_OPTIONAL_ITERATOR
+#   define __cpp_lib_optional_range_support             202406L
+# endif
 # undef  __cpp_lib_out_ptr
 # define __cpp_lib_out_ptr                              202311L
 // # define __cpp_lib_philox_engine                        202406L
 // # define __cpp_lib_ranges_concat                        202403L
+# define __cpp_lib_ranges_indices                       202506L
 # define __cpp_lib_ratio                                202306L
 // # define __cpp_lib_rcu                                  202306L
 # define __cpp_lib_reference_wrapper                    202403L
 @@ -599,6 +615,7 @@ __cpp_lib_void_t                                        201411L <type_traits>
 # define __cpp_lib_span_at                              202311L
 # define __cpp_lib_span_initializer_list                202311L
 # define __cpp_lib_sstream_from_string_view             202306L
+# define __cpp_lib_string_subview                       202506L
 # undef  __cpp_lib_string_view
 # define __cpp_lib_string_view                          202403L
 // # define __cpp_lib_submdspan                            202306L

lib/libcxx/include/wctype.h+29-29

...	@@ -45,13 +45,14 @@ wctrans_t wctrans(const char* property);	...	@@ -45,13 +45,14 @@ wctrans_t wctrans(const char* property);
45	*/	45	*/
46		46
47	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)	47	#if defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
48	# include <__cxx03/wctype.h>	48	# include <__cxx03/__config>
49	#else	49	#else
50	# include <__config>	50	# include <__config>
		51	#endif
51		52
52	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	53	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
53	# pragma GCC system_header	54	# pragma GCC system_header
54	# endif	55	#endif
55		56
56	// TODO:	57	// TODO:
57	// In the future, we should unconditionally include_next <wctype.h> here and instead	58	// In the future, we should unconditionally include_next <wctype.h> here and instead
...	@@ -62,33 +63,32 @@ wctrans_t wctrans(const char* property);	...	@@ -62,33 +63,32 @@ wctrans_t wctrans(const char* property);
62	// nothing (with using_if_exists), and if we include another header that defines one	63	// nothing (with using_if_exists), and if we include another header that defines one
63	// of these declarations (e.g. <wchar.h>), the second `using ::wint_t` with using_if_exists	64	// of these declarations (e.g. <wchar.h>), the second `using ::wint_t` with using_if_exists
64	// will fail because it does not refer to the same declaration.	65	// will fail because it does not refer to the same declaration.
65	# if __has_include_next(<wctype.h>)	66	#if __has_include_next(<wctype.h>)
66	# include_next <wctype.h>	67	# include_next <wctype.h>
67	# define _LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H	68	# define _LIBCPP_INCLUDED_C_LIBRARY_WCTYPE_H
68	# endif	69	#endif
69		70
70	# ifdef __cplusplus	71	#ifdef __cplusplus
71		72
72	# undef iswalnum	73	# undef iswalnum
73	# undef iswalpha	74	# undef iswalpha
74	# undef iswblank	75	# undef iswblank
75	# undef iswcntrl	76	# undef iswcntrl
76	# undef iswdigit	77	# undef iswdigit
77	# undef iswgraph	78	# undef iswgraph
78	# undef iswlower	79	# undef iswlower
79	# undef iswprint	80	# undef iswprint
80	# undef iswpunct	81	# undef iswpunct
81	# undef iswspace	82	# undef iswspace
82	# undef iswupper	83	# undef iswupper
83	# undef iswxdigit	84	# undef iswxdigit
84	# undef iswctype	85	# undef iswctype
85	# undef wctype	86	# undef wctype
86	# undef towlower	87	# undef towlower
87	# undef towupper	88	# undef towupper
88	# undef towctrans	89	# undef towctrans
89	# undef wctrans	90	# undef wctrans
90		91
91	# endif // __cplusplus	92	#endif // __cplusplus
92	#endif // defined(__cplusplus) && __cplusplus < 201103L && defined(_LIBCPP_USE_FROZEN_CXX03_HEADERS)
93		93
94	#endif // _LIBCPP_WCTYPE_H	94	#endif // _LIBCPP_WCTYPE_H

lib/libcxx/src/any.cpp+4

...	@@ -14,6 +14,8 @@ const char* bad_any_cast::what() const noexcept { return "bad any cast"; }	...	@@ -14,6 +14,8 @@ const char* bad_any_cast::what() const noexcept { return "bad any cast"; }
14		14
15	#include <__config>	15	#include <__config>
16		16
		17	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 7
		18
17	// Preserve std::experimental::any_bad_cast for ABI compatibility	19	// Preserve std::experimental::any_bad_cast for ABI compatibility
18	// Even though it no longer exists in a header file	20	// Even though it no longer exists in a header file
19	_LIBCPP_BEGIN_NAMESPACE_LFTS	21	_LIBCPP_BEGIN_NAMESPACE_LFTS
...	@@ -25,4 +27,6 @@ public:	...	@@ -25,4 +27,6 @@ public:
25		27
26	const char* bad_any_cast::what() const noexcept { return "bad any cast"; }	28	const char* bad_any_cast::what() const noexcept { return "bad any cast"; }
27		29
		30	#endif
		31
28	_LIBCPP_END_NAMESPACE_LFTS	32	_LIBCPP_END_NAMESPACE_LFTS

lib/libcxx/src/atomic.cpp+365-80

...	@@ -9,8 +9,13 @@	...	@@ -9,8 +9,13 @@
9	#include <__thread/timed_backoff_policy.h>	9	#include <__thread/timed_backoff_policy.h>
10	#include <atomic>	10	#include <atomic>
11	#include <climits>	11	#include <climits>
		12	#include <cstddef>
		13	#include <cstdint>
		14	#include <cstring>
12	#include <functional>	15	#include <functional>
		16	#include <new>
13	#include <thread>	17	#include <thread>
		18	#include <type_traits>
14		19
15	#include "include/apple_availability.h"	20	#include "include/apple_availability.h"
16		21
...	@@ -41,6 +46,11 @@	...	@@ -41,6 +46,11 @@
41	// OpenBSD has no indirect syscalls	46	// OpenBSD has no indirect syscalls
42	# define _LIBCPP_FUTEX(...) futex(__VA_ARGS__)	47	# define _LIBCPP_FUTEX(...) futex(__VA_ARGS__)
43		48
		49	#elif defined(_WIN32)
		50
		51	# include <memory>
		52	# include <windows.h>
		53
44	#else // <- Add other operating systems here	54	#else // <- Add other operating systems here
45		55
46	// Baseline needs no new headers	56	// Baseline needs no new headers
...	@@ -49,17 +59,34 @@	...	@@ -49,17 +59,34 @@
49		59
50	#endif	60	#endif
51		61
		62	_LIBCPP_PUSH_MACROS
		63	#include <__undef_macros>
		64
52	_LIBCPP_BEGIN_NAMESPACE_STD	65	_LIBCPP_BEGIN_NAMESPACE_STD
53		66
		67	struct NoTimeout {};
		68
54	#ifdef __linux__	69	#ifdef __linux__
55		70
56	static void	71	template <std::size_t _Size, class MaybeTimeout>
57	__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {	72	static void __platform_wait_on_address(void const* __ptr, void const* __val, MaybeTimeout maybe_timeout_ns) {
58	static constexpr timespec __timeout = {2, 0};	73	static_assert(_Size == 4, "Can only wait on 4 bytes value");
59	_LIBCPP_FUTEX(__ptr, FUTEX_WAIT_PRIVATE, __val, &__timeout, 0, 0);	74	alignas(__cxx_contention_t) char buffer[_Size];
		75	std::memcpy(&buffer, const_cast<const void*>(__val), _Size);
		76	static constexpr timespec __default_timeout = {2, 0};
		77	timespec __timeout;
		78	if constexpr (is_same_v<MaybeTimeout, NoTimeout>) {
		79	__timeout = __default_timeout;
		80	} else {
		81	__timeout.tv_sec = maybe_timeout_ns / 1'000'000'000;
		82	__timeout.tv_nsec = maybe_timeout_ns % 1'000'000'000;
		83	}
		84	_LIBCPP_FUTEX(__ptr, FUTEX_WAIT_PRIVATE, reinterpret_cast<__cxx_contention_t const>(&buffer), &__timeout, 0, 0);
60	}	85	}
61		86
62	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr, bool __notify_one) {	87	template <std::size_t _Size>
		88	static void __platform_wake_by_address(void const* __ptr, bool __notify_one) {
		89	static_assert(_Size == 4, "Can only wake up on 4 bytes value");
63	_LIBCPP_FUTEX(__ptr, FUTEX_WAKE_PRIVATE, __notify_one ? 1 : INT_MAX, 0, 0, 0);	90	_LIBCPP_FUTEX(__ptr, FUTEX_WAKE_PRIVATE, __notify_one ? 1 : INT_MAX, 0, 0, 0);
64	}	91	}
65		92
...	@@ -70,19 +97,41 @@ extern "C" int __ulock_wait(	...	@@ -70,19 +97,41 @@ extern "C" int __ulock_wait(
70	extern "C" int __ulock_wake(uint32_t operation, void* addr, uint64_t wake_value);	97	extern "C" int __ulock_wake(uint32_t operation, void* addr, uint64_t wake_value);
71		98
72	// https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/ulock.h#L82	99	// https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/ulock.h#L82
		100	# define UL_COMPARE_AND_WAIT 1
73	# define UL_COMPARE_AND_WAIT64 5	101	# define UL_COMPARE_AND_WAIT64 5
74	# define ULF_WAKE_ALL 0x00000100	102	# define ULF_WAKE_ALL 0x00000100
75		103
76	static void	104	template <std::size_t _Size, class MaybeTimeout>
77	__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {	105	static void __platform_wait_on_address(void const* __ptr, void const* __val, MaybeTimeout maybe_timeout_ns) {
78	static_assert(sizeof(__cxx_atomic_contention_t) == 8, "Waiting on 8 bytes value");	106	static_assert(_Size == 8 \|\| _Size == 4, "Can only wait on 8 bytes or 4 bytes value");
79	__ulock_wait(UL_COMPARE_AND_WAIT64, const_cast<__cxx_atomic_contention_t*>(__ptr), __val, 0);	107	auto __timeout_us = [&] {
		108	if constexpr (is_same_v<MaybeTimeout, NoTimeout>) {
		109	return uint32_t(0);
		110	} else {
		111	return std::max(static_cast<uint32_t>(maybe_timeout_ns / 1000), uint32_t(1));
		112	}
		113	}();
		114	if constexpr (_Size == 4) {
		115	alignas(uint32_t) char buffer[_Size];
		116	std::memcpy(&buffer, const_cast<const void*>(__val), _Size);
		117	__ulock_wait(
		118	UL_COMPARE_AND_WAIT, const_cast<void>(__ptr), reinterpret_cast<uint32_t const*>(&buffer), __timeout_us);
		119	} else {
		120	alignas(uint64_t) char buffer[_Size];
		121	std::memcpy(&buffer, const_cast<const void*>(__val), _Size);
		122	__ulock_wait(
		123	UL_COMPARE_AND_WAIT64, const_cast<void>(__ptr), reinterpret_cast<uint64_t const*>(&buffer), __timeout_us);
		124	}
80	}	125	}
81		126
82	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr, bool __notify_one) {	127	template <std::size_t _Size>
83	static_assert(sizeof(__cxx_atomic_contention_t) == 8, "Waking up on 8 bytes value");	128	static void __platform_wake_by_address(void const* __ptr, bool __notify_one) {
84	__ulock_wake(	129	static_assert(_Size == 8 \|\| _Size == 4, "Can only wake up on 8 bytes or 4 bytes value");
85	UL_COMPARE_AND_WAIT64 \| (__notify_one ? 0 : ULF_WAKE_ALL), const_cast<__cxx_atomic_contention_t*>(__ptr), 0);	130
		131	if constexpr (_Size == 4)
		132	__ulock_wake(UL_COMPARE_AND_WAIT \| (__notify_one ? 0 : ULF_WAKE_ALL), const_cast<void*>(__ptr), 0);
		133	else
		134	__ulock_wake(UL_COMPARE_AND_WAIT64 \| (__notify_one ? 0 : ULF_WAKE_ALL), const_cast<void*>(__ptr), 0);
86	}	135	}
87		136
88	#elif defined(__FreeBSD__) && __SIZEOF_LONG__ == 8	137	#elif defined(__FreeBSD__) && __SIZEOF_LONG__ == 8
...	@@ -92,119 +141,355 @@ static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const vo	...	@@ -92,119 +141,355 @@ static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const vo
92	* limit its use to architectures where long and int64_t are synonyms.	141	* limit its use to architectures where long and int64_t are synonyms.
93	*/	142	*/
94		143
95	static void	144	template <std::size_t _Size, class MaybeTimeout>
96	__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {	145	static void __platform_wait_on_address(void const* __ptr, void const* __val, MaybeTimeout maybe_timeout_ns) {
97	_umtx_op(const_cast<__cxx_atomic_contention_t*>(__ptr), UMTX_OP_WAIT, __val, nullptr, nullptr);	146	static_assert(_Size == 8, "Can only wait on 8 bytes value");
		147	// At the moment, FreeBSD is stuck on stable ABI, which only supports platform wait with __cxx_contention_t
		148	// It is safe to reinterpret_cast the val as it is ever going to be passed a __cxx_contention_t under this ABI
		149	// If in the future FreeBSD decides to experiment unstable ABI to support more types, this cast will no longer be
		150	// safe.
		151	__cxx_contention_t value = reinterpret_cast<const __cxx_contention_t>(__val);
		152	if constexpr (is_same_v<MaybeTimeout, NoTimeout>) {
		153	_umtx_op(const_cast<void*>(__ptr), UMTX_OP_WAIT, value, nullptr, nullptr);
		154	} else {
		155	timespec timeout{};
		156	timeout.tv_sec = maybe_timeout_ns / 1'000'000'000;
		157	timeout.tv_nsec = maybe_timeout_ns % 1'000'000'000;
		158
		159	_umtx_op(const_cast<void*>(__ptr),
		160	UMTX_OP_WAIT,
		161	value,
		162	reinterpret_cast<void*>(static_cast<uintptr_t>(sizeof(timeout))),
		163	&timeout);
		164	}
		165	}
		166
		167	template <std::size_t _Size>
		168	static void __platform_wake_by_address(void const* __ptr, bool __notify_one) {
		169	static_assert(_Size == 8, "Can only wake up on 8 bytes value");
		170	_umtx_op(const_cast<void*>(__ptr), UMTX_OP_WAKE, __notify_one ? 1 : INT_MAX, nullptr, nullptr);
		171	}
		172
		173	#elif defined(_WIN32)
		174
		175	static void* win32_get_synch_api_function(const char* function_name) {
		176	// Attempt to load the API set. Note that as per the Microsoft STL implementation, we assume this API is already
		177	// loaded and accessible. While this isn't explicitly guaranteed by publicly available Win32 API documentation, it is
		178	// true in practice, and may be guaranteed by internal documentation not released publicly. In any case the fact that
		179	// the Microsoft STL made this assumption is reasonable basis to say that we can too. The alternative to this would be
		180	// to use LoadLibrary, but then leak the module handle. We can't call FreeLibrary, as this would have to be triggered
		181	// by a global static destructor, which would hang off DllMain, and calling FreeLibrary from DllMain is explicitly
		182	// mentioned as not being allowed:
		183	// https://learn.microsoft.com/en-us/windows/win32/dlls/dllmain
		184	// Given the range of bad options here, we have chosen to mirror what Microsoft did, as it seems fair to assume that
		185	// Microsoft will guarantee compatibility for us, as we are exposed to the same conditions as all existing Windows
		186	// apps using the Microsoft STL VS2015/2017/2019/2022 runtimes, where Windows 7 support has not been excluded at
		187	// compile time.
		188	static auto module_handle = GetModuleHandleW(L"api-ms-win-core-synch-l1-2-0.dll");
		189	if (module_handle == nullptr) {
		190	return nullptr;
		191	}
		192
		193	// Attempt to locate the function in the API and return the result to the caller. Note that the NULL return from this
		194	// method is documented as being interchangeable with nullptr.
		195	// https://devblogs.microsoft.com/oldnewthing/20180307-00/?p=98175
		196	return reinterpret_cast<void*>(GetProcAddress(module_handle, function_name));
98	}	197	}
99		198
100	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile* __ptr, bool __notify_one) {	199	template <std::size_t _Size, class MaybeTimeout>
101	_umtx_op(const_cast<__cxx_atomic_contention_t*>(__ptr), UMTX_OP_WAKE, __notify_one ? 1 : INT_MAX, nullptr, nullptr);	200	static void __platform_wait_on_address(void const* __ptr, void const* __val, MaybeTimeout maybe_timeout_ns) {
		201	static_assert(_Size == 8, "Can only wait on 8 bytes value");
		202	// WaitOnAddress was added in Windows 8 (build 9200)
		203	static auto wait_on_address =
		204	reinterpret_cast<BOOL(WINAPI)(void, PVOID, SIZE_T, DWORD)>(win32_get_synch_api_function("WaitOnAddress"));
		205	if (wait_on_address != nullptr) {
		206	auto timeout_ms = [&]() -> DWORD {
		207	if constexpr (is_same_v<MaybeTimeout, NoTimeout>) {
		208	return INFINITE;
		209	} else {
		210	uint64_t ms = maybe_timeout_ns / 1'000'000;
		211	if (ms == 0 && maybe_timeout_ns > 100'000)
		212	// Round up to 1ms if requested between 100us - 1ms
		213	return 1;
		214
		215	return static_cast<DWORD>(std::min(static_cast<uint64_t>(INFINITE), ms));
		216	}
		217	}();
		218	wait_on_address(const_cast<void>(__ptr), const_cast<void>(__val), _Size, timeout_ms);
		219	} else {
		220	std::chrono::nanoseconds timeout = std::chrono::nanoseconds(0);
		221	if constexpr (!is_same_v<MaybeTimeout, NoTimeout>) {
		222	timeout = std::chrono::nanoseconds(maybe_timeout_ns);
		223	}
		224	__libcpp_thread_poll_with_backoff(
		225	[=]() -> bool { return std::memcmp(const_cast<const void*>(__ptr), __val, _Size) != 0; },
		226	__libcpp_timed_backoff_policy(),
		227	timeout);
		228	}
		229	}
		230
		231	template <std::size_t _Size>
		232	static void __platform_wake_by_address(void const* __ptr, bool __notify_one) {
		233	static_assert(_Size == 8, "Can only wake up on 8 bytes value");
		234	if (__notify_one) {
		235	// WakeByAddressSingle was added in Windows 8 (build 9200)
		236	static auto wake_by_address_single =
		237	reinterpret_cast<void(WINAPI*)(PVOID)>(win32_get_synch_api_function("WakeByAddressSingle"));
		238	if (wake_by_address_single != nullptr) {
		239	wake_by_address_single(const_cast<void*>(__ptr));
		240	} else {
		241	// The fallback implementation of waking does nothing, as the fallback wait implementation just does polling, so
		242	// there's nothing to do here.
		243	}
		244	} else {
		245	// WakeByAddressAll was added in Windows 8 (build 9200)
		246	static auto wake_by_address_all =
		247	reinterpret_cast<void(WINAPI*)(PVOID)>(win32_get_synch_api_function("WakeByAddressAll"));
		248	if (wake_by_address_all != nullptr) {
		249	wake_by_address_all(const_cast<void*>(__ptr));
		250	} else {
		251	// The fallback implementation of waking does nothing, as the fallback wait implementation just does polling, so
		252	// there's nothing to do here.
		253	}
		254	}
102	}	255	}
103		256
104	#else // <- Add other operating systems here	257	#else // <- Add other operating systems here
105		258
106	// Baseline is just a timed backoff	259	// Baseline is just a timed backoff
107		260
108	static void	261	template <std::size_t _Size, class MaybeTimeout>
109	__libcpp_platform_wait_on_address(__cxx_atomic_contention_t const volatile* __ptr, __cxx_contention_t __val) {	262	static void __platform_wait_on_address(void const* __ptr, void const* __val, MaybeTimeout maybe_timeout_ns) {
		263	std::chrono::nanoseconds timeout = std::chrono::nanoseconds(0);
		264	if constexpr (!is_same_v<MaybeTimeout, NoTimeout>) {
		265	timeout = std::chrono::nanoseconds(maybe_timeout_ns);
		266	}
110	__libcpp_thread_poll_with_backoff(	267	__libcpp_thread_poll_with_backoff(
111	[=]() -> bool { return !__cxx_nonatomic_compare_equal(__cxx_atomic_load(__ptr, memory_order_relaxed), __val); },	268	[=]() -> bool { return std::memcmp(const_cast<const void*>(__ptr), __val, _Size) != 0; },
112	__libcpp_timed_backoff_policy());	269	__libcpp_timed_backoff_policy(),
		270	timeout);
113	}	271	}
114		272
115	static void __libcpp_platform_wake_by_address(__cxx_atomic_contention_t const volatile*, bool) {}	273	template <std::size_t _Size>
		274	static void __platform_wake_by_address(void const*, bool) {}
116		275
117	#endif // __linux__	276	#endif // __linux__
118		277
119	static constexpr size_t __libcpp_contention_table_size = (1 << 8); /* < there's no magic in this number */	278	// =============================
120		279	// Local hidden helper functions
121	struct alignas(64) /* aim to avoid false sharing */ __libcpp_contention_table_entry {	280	// =============================
122	__cxx_atomic_contention_t __contention_state;
123	__cxx_atomic_contention_t __platform_state;
124	inline constexpr __libcpp_contention_table_entry() : __contention_state(0), __platform_state(0) {}
125	};
126
127	static __libcpp_contention_table_entry __libcpp_contention_table[__libcpp_contention_table_size];
128
129	static hash<void const volatile*> __libcpp_contention_hasher;
130
131	static __libcpp_contention_table_entry* __libcpp_contention_state(void const volatile* p) {
132	return &__libcpp_contention_table[__libcpp_contention_hasher(p) & (__libcpp_contention_table_size - 1)];
133	}
134		281
135	/* Given an atomic to track contention and an atomic to actually wait on, which may be	282	/* Given an atomic to track contention and an atomic to actually wait on, which may be
136	the same atomic, we try to detect contention to avoid spuriously calling the platform. */	283	the same atomic, we try to detect contention to avoid spuriously calling the platform. */
137		284
138	static void __libcpp_contention_notify(__cxx_atomic_contention_t volatile* __contention_state,	285	template <std::size_t _Size>
139	__cxx_atomic_contention_t const volatile* __platform_state,	286	static void
140	bool __notify_one) {	287	__contention_notify(__cxx_atomic_contention_t* __waiter_count, void const* __address_to_notify, bool __notify_one) {
141	if (0 != __cxx_atomic_load(__contention_state, memory_order_seq_cst))	288	if (0 != __cxx_atomic_load(__waiter_count, memory_order_seq_cst))
142	// We only call 'wake' if we consumed a contention bit here.	289	// We only call 'wake' if we consumed a contention bit here.
143	__libcpp_platform_wake_by_address(__platform_state, __notify_one);	290	__platform_wake_by_address<_Size>(__address_to_notify, __notify_one);
144	}	291	}
145	static __cxx_contention_t	292
146	__libcpp_contention_monitor_for_wait(__cxx_atomic_contention_t volatile* /__contention_state/,	293	template <std::size_t _Size, class MaybeTimeout>
147	__cxx_atomic_contention_t const volatile* __platform_state) {	294	static void __contention_wait(__cxx_atomic_contention_t* __waiter_count,
148	// We will monitor this value.	295	void const* __address_to_wait,
149	return __cxx_atomic_load(__platform_state, memory_order_acquire);	296	void const* __old_value,
150	}	297	MaybeTimeout maybe_timeout_ns) {
151	static void __libcpp_contention_wait(__cxx_atomic_contention_t volatile* __contention_state,	298	__cxx_atomic_fetch_add(__waiter_count, __cxx_contention_t(1), memory_order_relaxed);
152	__cxx_atomic_contention_t const volatile* __platform_state,	299	// https://llvm.org/PR109290
153	__cxx_contention_t __old_value) {
154	__cxx_atomic_fetch_add(__contention_state, __cxx_contention_t(1), memory_order_relaxed);
155	// https://github.com/llvm/llvm-project/issues/109290
156	// There are no platform guarantees of a memory barrier in the platform wait implementation	300	// There are no platform guarantees of a memory barrier in the platform wait implementation
157	__cxx_atomic_thread_fence(memory_order_seq_cst);	301	__cxx_atomic_thread_fence(memory_order_seq_cst);
158	// We sleep as long as the monitored value hasn't changed.	302	// We sleep as long as the monitored value hasn't changed.
159	__libcpp_platform_wait_on_address(__platform_state, __old_value);	303	__platform_wait_on_address<_Size>(__address_to_wait, __old_value, maybe_timeout_ns);
160	__cxx_atomic_fetch_sub(__contention_state, __cxx_contention_t(1), memory_order_release);	304	__cxx_atomic_fetch_sub(__waiter_count, __cxx_contention_t(1), memory_order_release);
		305	}
		306
		307	static constexpr size_t __contention_table_size = (1 << 8); /* < there's no magic in this number */
		308
		309	static constexpr hash<void const*> __contention_hasher;
		310
		311	// Waiter count table for all atomics with the correct size that use itself as the wait/notify address.
		312
		313	struct alignas(
		314	std::hardware_constructive_interference_size) /* aim to avoid false sharing */ __contention_state_native {
		315	__cxx_atomic_contention_t __waiter_count;
		316	constexpr __contention_state_native() : __waiter_count(0) {}
		317	};
		318
		319	static __contention_state_native __contention_table_native[__contention_table_size];
		320
		321	static __cxx_atomic_contention_t* __get_native_waiter_count(void const* p) {
		322	return &__contention_table_native[__contention_hasher(p) & (__contention_table_size - 1)].__waiter_count;
		323	}
		324
		325	// Global contention table for all atomics with the wrong size that use the global table's atomic as wait/notify
		326	// address.
		327
		328	struct alignas(
		329	std::hardware_constructive_interference_size) /* aim to avoid false sharing */ __contention_state_global {
		330	__cxx_atomic_contention_t __waiter_count;
		331	__cxx_atomic_contention_t __platform_state;
		332	constexpr __contention_state_global() : __waiter_count(0), __platform_state(0) {}
		333	};
		334
		335	static __contention_state_global __contention_table_global[__contention_table_size];
		336
		337	static __contention_state_global* __get_global_contention_state(void const* p) {
		338	return &__contention_table_global[__contention_hasher(p) & (__contention_table_size - 1)];
161	}	339	}
162		340
163	/* When the incoming atomic is the wrong size for the platform wait size, need to	341	/* When the incoming atomic is the wrong size for the platform wait size, need to
164	launder the value sequence through an atomic from our table. */	342	launder the value sequence through an atomic from our table. */
165		343
166	static void __libcpp_atomic_notify(void const volatile* __location) {	344	static void __atomic_notify_global_table(void const* __location) {
167	auto const __entry = __libcpp_contention_state(__location);	345	auto const __entry = __get_global_contention_state(__location);
168	// The value sequence laundering happens on the next line below.	346	// The value sequence laundering happens on the next line below.
169	__cxx_atomic_fetch_add(&__entry->__platform_state, __cxx_contention_t(1), memory_order_seq_cst);	347	__cxx_atomic_fetch_add(&__entry->__platform_state, __cxx_contention_t(1), memory_order_seq_cst);
170	__libcpp_contention_notify(	348	__contention_notify<sizeof(__cxx_atomic_contention_t)>(
171	&__entry->__contention_state,	349	&__entry->__waiter_count, &__entry->__platform_state, false /* when laundering, we can't handle notify_one */);
172	&__entry->__platform_state,	350	}
173	false /* when laundering, we can't handle notify_one */);	351
		352	// =============================
		353	// New dylib exported symbols
		354	// =============================
		355
		356	// global
		357	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __atomic_monitor_global(void const* __location) noexcept {
		358	auto const __entry = __get_global_contention_state(__location);
		359	return __cxx_atomic_load(&__entry->__platform_state, memory_order_acquire);
		360	}
		361
		362	_LIBCPP_EXPORTED_FROM_ABI void
		363	__atomic_wait_global_table(void const* __location, __cxx_contention_t __old_value) noexcept {
		364	auto const __entry = __get_global_contention_state(__location);
		365	__contention_wait<sizeof(__cxx_atomic_contention_t)>(
		366	&__entry->__waiter_count, &__entry->__platform_state, &__old_value, NoTimeout{});
		367	}
		368
		369	_LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_global_table_with_timeout(
		370	void const* __location, __cxx_contention_t __old_value, uint64_t __timeout_ns) _NOEXCEPT {
		371	auto const __entry = __get_global_contention_state(__location);
		372	__contention_wait<sizeof(__cxx_atomic_contention_t)>(
		373	&__entry->__waiter_count, &__entry->__platform_state, &__old_value, __timeout_ns);
		374	}
		375
		376	_LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_one_global_table(void const* __location) noexcept {
		377	__atomic_notify_global_table(__location);
		378	}
		379
		380	_LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_all_global_table(void const* __location) noexcept {
		381	__atomic_notify_global_table(__location);
		382	}
		383
		384	// native
		385
		386	template <std::size_t _Size>
		387	_LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_native(void const* __address, void const* __old_value) noexcept {
		388	__contention_wait<_Size>(__get_native_waiter_count(__address), __address, __old_value, NoTimeout{});
174	}	389	}
		390
		391	template <std::size_t _Size>
		392	_LIBCPP_EXPORTED_FROM_ABI void
		393	__atomic_wait_native_with_timeout(void const* __address, void const* __old_value, uint64_t __timeout_ns) noexcept {
		394	__contention_wait<_Size>(__get_native_waiter_count(__address), __address, __old_value, __timeout_ns);
		395	}
		396
		397	template <std::size_t _Size>
		398	_LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_one_native(void const* __location) noexcept {
		399	__contention_notify<_Size>(__get_native_waiter_count(__location), __location, true);
		400	}
		401
		402	template <std::size_t _Size>
		403	_LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_all_native(void const* __location) noexcept {
		404	__contention_notify<_Size>(__get_native_waiter_count(__location), __location, false);
		405	}
		406
		407	// ==================================================
		408	// Instantiation of the templates with supported size
		409	// ==================================================
		410
		411	#if defined(_LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE)
		412
		413	# define _INSTANTIATE(_SIZE) \
		414	template _LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_native<_SIZE>(void const, void const) noexcept; \
		415	template _LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_native_with_timeout<_SIZE>( \
		416	void const, void const, uint64_t) noexcept; \
		417	template _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_one_native<_SIZE>(void const*) noexcept; \
		418	template _LIBCPP_EXPORTED_FROM_ABI void __atomic_notify_all_native<_SIZE>(void const*) noexcept;
		419
		420	_LIBCPP_NATIVE_PLATFORM_WAIT_SIZES(_INSTANTIATE)
		421
		422	# undef _INSTANTIATE
		423
		424	#else // _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
		425
		426	template _LIBCPP_EXPORTED_FROM_ABI void
		427	__atomic_wait_native<sizeof(__cxx_contention_t)>(void const* __address, void const* __old_value) noexcept;
		428
		429	template _LIBCPP_EXPORTED_FROM_ABI void __atomic_wait_native_with_timeout<sizeof(__cxx_contention_t)>(
		430	void const* __address, void const* __old_value, uint64_t) noexcept;
		431
		432	template _LIBCPP_EXPORTED_FROM_ABI void
		433	__atomic_notify_one_native<sizeof(__cxx_contention_t)>(void const* __location) noexcept;
		434
		435	template _LIBCPP_EXPORTED_FROM_ABI void
		436	__atomic_notify_all_native<sizeof(__cxx_contention_t)>(void const* __location) noexcept;
		437
		438	#endif // _LIBCPP_ABI_ATOMIC_WAIT_NATIVE_BY_SIZE
		439
		440	// =============================================================
		441	// Old dylib exported symbols, for backwards compatibility
		442	// =============================================================
		443	_LIBCPP_DIAGNOSTIC_PUSH
		444	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-prototypes")
		445
175	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile* __location) noexcept {	446	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(void const volatile* __location) noexcept {
176	__libcpp_atomic_notify(__location);	447	__atomic_notify_global_table(const_cast<void const*>(__location));
177	}	448	}
		449
178	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile* __location) noexcept {	450	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(void const volatile* __location) noexcept {
179	__libcpp_atomic_notify(__location);	451	__atomic_notify_global_table(const_cast<void const*>(__location));
180	}	452	}
		453
181	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(void const volatile* __location) noexcept {	454	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t __libcpp_atomic_monitor(void const volatile* __location) noexcept {
182	auto const __entry = __libcpp_contention_state(__location);	455	auto const __entry = __get_global_contention_state(const_cast<void const*>(__location));
183	return __libcpp_contention_monitor_for_wait(&__entry->__contention_state, &__entry->__platform_state);	456	return __cxx_atomic_load(&__entry->__platform_state, memory_order_acquire);
184	}	457	}
		458
185	_LIBCPP_EXPORTED_FROM_ABI void	459	_LIBCPP_EXPORTED_FROM_ABI void
186	__libcpp_atomic_wait(void const volatile* __location, __cxx_contention_t __old_value) noexcept {	460	__libcpp_atomic_wait(void const volatile* __location, __cxx_contention_t __old_value) noexcept {
187	auto const __entry = __libcpp_contention_state(__location);	461	auto const __entry = __get_global_contention_state(const_cast<void const*>(__location));
188	__libcpp_contention_wait(&__entry->__contention_state, &__entry->__platform_state, __old_value);	462	__contention_wait<sizeof(__cxx_atomic_contention_t)>(
		463	&__entry->__waiter_count, &__entry->__platform_state, &__old_value, NoTimeout{});
189	}	464	}
190		465
191	/* When the incoming atomic happens to be the platform wait size, we still need to use the
192	table for the contention detection, but we can use the atomic directly for the wait. */
193
194	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile* __location) noexcept {	466	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_one(__cxx_atomic_contention_t const volatile* __location) noexcept {
195	__libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, true);	467	auto __location_cast = const_cast<const void>(static_cast<const volatile void>(__location));
		468	__contention_notify<sizeof(__cxx_atomic_contention_t)>(
		469	__get_native_waiter_count(__location_cast), __location_cast, true);
196	}	470	}
		471
197	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile* __location) noexcept {	472	_LIBCPP_EXPORTED_FROM_ABI void __cxx_atomic_notify_all(__cxx_atomic_contention_t const volatile* __location) noexcept {
198	__libcpp_contention_notify(&__libcpp_contention_state(__location)->__contention_state, __location, false);	473	auto __location_cast = const_cast<const void>(static_cast<const volatile void>(__location));
199	}	474	__contention_notify<sizeof(__cxx_atomic_contention_t)>(
200	// This function is never used, but still exported for ABI compatibility.	475	__get_native_waiter_count(__location_cast), __location_cast, false);
201	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
202	__libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile* __location) noexcept {
203	return __libcpp_contention_monitor_for_wait(&__libcpp_contention_state(__location)->__contention_state, __location);
204	}	476	}
		477
205	_LIBCPP_EXPORTED_FROM_ABI void	478	_LIBCPP_EXPORTED_FROM_ABI void
206	__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile* __location, __cxx_contention_t __old_value) noexcept {	479	__libcpp_atomic_wait(__cxx_atomic_contention_t const volatile* __location, __cxx_contention_t __old_value) noexcept {
207	__libcpp_contention_wait(&__libcpp_contention_state(__location)->__contention_state, __location, __old_value);	480	auto __location_cast = const_cast<const void>(static_cast<const volatile void>(__location));
		481	__contention_wait<sizeof(__cxx_atomic_contention_t)>(
		482	__get_native_waiter_count(__location_cast), __location_cast, &__old_value, NoTimeout{});
208	}	483	}
209		484
		485	// this function is even unused in the old ABI
		486	_LIBCPP_EXPORTED_FROM_ABI __cxx_contention_t
		487	__libcpp_atomic_monitor(__cxx_atomic_contention_t const volatile* __location) noexcept {
		488	return __cxx_atomic_load(__location, memory_order_acquire);
		489	}
		490
		491	_LIBCPP_DIAGNOSTIC_POP
		492
210	_LIBCPP_END_NAMESPACE_STD	493	_LIBCPP_END_NAMESPACE_STD
		494
		495	_LIBCPP_POP_MACROS

lib/libcxx/src/barrier.cpp+4-3

 @@ -60,11 +60,12 @@ public:
 _LIBCPP_EXPORTED_FROM_ABI __barrier_algorithm_base* __construct_barrier_algorithm_base(ptrdiff_t& __expected) {
   return new __barrier_algorithm_base(__expected);
 }
-_LIBCPP_EXPORTED_FROM_ABI bool
+_LIBCPP_EXPORTED_FROM_ABI bool __arrive_barrier_algorithm_base(
-__arrive_barrier_algorithm_base(__barrier_algorithm_base* __barrier, __barrier_phase_t __old_phase) noexcept {
+    _LIBCPP_NOESCAPE __barrier_algorithm_base* __barrier, __barrier_phase_t __old_phase) noexcept {
   return __barrier->__arrive(__old_phase);
 }
-_LIBCPP_EXPORTED_FROM_ABI void __destroy_barrier_algorithm_base(__barrier_algorithm_base* __barrier) noexcept {
+_LIBCPP_EXPORTED_FROM_ABI void
+__destroy_barrier_algorithm_base(_LIBCPP_NOESCAPE __barrier_algorithm_base* __barrier) noexcept {
   delete __barrier;
 }

lib/libcxx/src/charconv.cpp+6-3

 @@ -14,17 +14,20 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 15
 namespace __itoa {
+_LIBCPP_DIAGNOSTIC_PUSH
+_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-prototypes")
+// These functions exist for ABI compatibility, so we don't ever want a declaration prior to the definition.
 _LIBCPP_EXPORTED_FROM_ABI char* __u32toa(uint32_t value, char* buffer) noexcept { return __base_10_u32(buffer, value); }
 _LIBCPP_EXPORTED_FROM_ABI char* __u64toa(uint64_t value, char* buffer) noexcept { return __base_10_u64(buffer, value); }
+_LIBCPP_DIAGNOSTIC_POP
 } // namespace __itoa
-#endif // _LIBCPP_ABI_DO_NOT_EXPORT_TO_CHARS_BASE_10
+#endif // _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 15
 // The original version of floating-point to_chars was written by Microsoft and
 // contributed with the following license.

lib/libcxx/src/condition_variable_destructor.cpp+1-1

...	@@ -14,7 +14,7 @@	...	@@ -14,7 +14,7 @@
14	#include <__config>	14	#include <__config>
15	#include <__thread/support.h>	15	#include <__thread/support.h>
16		16
17	#if _LIBCPP_ABI_VERSION == 1 \|\| !_LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION	17	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 9 \|\| !_LIBCPP_HAS_TRIVIAL_CONDVAR_DESTRUCTION
18	# define NEEDS_CONDVAR_DESTRUCTOR	18	# define NEEDS_CONDVAR_DESTRUCTOR
19	#endif	19	#endif
20		20

lib/libcxx/src/error_category.cpp+3-1

...	@@ -8,7 +8,9 @@	...	@@ -8,7 +8,9 @@
8		8
9	#include <__config>	9	#include <__config>
10		10
11	#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS	11	// This has technically been removed in LLVM 3.4
		12	#if !defined(_LIBCPP_OBJECT_FORMAT_COFF) && !defined(_LIBCPP_OBJECT_FORMAT_XCOFF) && \
		13	_LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 4
12	# define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS	14	# define _LIBCPP_ERROR_CATEGORY_DEFINE_LEGACY_INLINE_FUNCTIONS
13	#endif	15	#endif
14		16

lib/libcxx/src/exception.cpp+2-10

 @@ -9,20 +9,12 @@
 #define _LIBCPP_ENABLE_CXX20_REMOVED_UNCAUGHT_EXCEPTION
 #define _LIBCPP_DISABLE_DEPRECATION_WARNINGS
-#include <exception>
+#include <__config>
-#include <new>
-#include <typeinfo>
-#if defined(LIBCXXRT) || defined(LIBCXX_BUILDING_LIBCXXABI)
-#  include <cxxabi.h>
-using namespace __cxxabiv1;
-#  define HAVE_DEPENDENT_EH_ABI 1
-#endif
 #if defined(_LIBCPP_ABI_MICROSOFT)
 #  include "support/runtime/exception_msvc.ipp"
 #  include "support/runtime/exception_pointer_msvc.ipp"
-#elif defined(_LIBCPPABI_VERSION)
+#elif defined(LIBCXX_BUILDING_LIBCXXABI)
 #  include "support/runtime/exception_libcxxabi.ipp"
 #  include "support/runtime/exception_pointer_cxxabi.ipp"
 #elif defined(LIBCXXRT)

lib/libcxx/src/experimental/time_zone.cpp+1-1

...	@@ -720,7 +720,7 @@ __get_sys_info(sys_seconds __time,	...	@@ -720,7 +720,7 @@ __get_sys_info(sys_seconds __time,
720	// Iff the "offsets" are the same '__current.__end' is replaced with	720	// Iff the "offsets" are the same '__current.__end' is replaced with
721	// '__next.__end', which effectively merges the two objects in one object. The	721	// '__next.__end', which effectively merges the two objects in one object. The
722	// function returns true if a merge occurred.	722	// function returns true if a merge occurred.
723	[[nodiscard]] bool __merge_continuation(sys_info& __current, const sys_info& __next) {	723	[[nodiscard]] static bool __merge_continuation(sys_info& __current, const sys_info& __next) {
724	if (__current.end != __next.begin)	724	if (__current.end != __next.begin)
725	return false;	725	return false;
726		726

lib/libcxx/src/experimental/tzdb.cpp+4-1

...	@@ -49,6 +49,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD	...	@@ -49,6 +49,8 @@ _LIBCPP_BEGIN_NAMESPACE_STD
49		49
50	namespace chrono {	50	namespace chrono {
51		51
		52	_LIBCPP_DIAGNOSTIC_PUSH
		53	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-prototypes")
52	// This function is weak so it can be overriden in the tests. The	54	// This function is weak so it can be overriden in the tests. The
53	// declaration is in the test header test/support/test_tzdb.h	55	// declaration is in the test header test/support/test_tzdb.h
54	_LIBCPP_WEAK string_view __libcpp_tzdb_directory() {	56	_LIBCPP_WEAK string_view __libcpp_tzdb_directory() {
...	@@ -59,6 +61,7 @@ _LIBCPP_WEAK string_view __libcpp_tzdb_directory() {	...	@@ -59,6 +61,7 @@ _LIBCPP_WEAK string_view __libcpp_tzdb_directory() {
59	abort();	61	abort();
60	#endif	62	#endif
61	}	63	}
		64	_LIBCPP_DIAGNOSTIC_POP
62		65
63	//===----------------------------------------------------------------------===//	66	//===----------------------------------------------------------------------===//
64	// Details	67	// Details
...	@@ -767,7 +770,7 @@ void __init_tzdb(tzdb& __tzdb, __tz::__rules_storage_type& __rules) {	...	@@ -767,7 +770,7 @@ void __init_tzdb(tzdb& __tzdb, __tz::__rules_storage_type& __rules) {
767	// On Linux systems it seems /etc/timezone is deprecated and being phased out.	770	// On Linux systems it seems /etc/timezone is deprecated and being phased out.
768	// This file is used when /etc/localtime does not exist, or when it exists but	771	// This file is used when /etc/localtime does not exist, or when it exists but
769	// is not a symlink. For more information and links see	772	// is not a symlink. For more information and links see
770	// https://github.com/llvm/llvm-project/issues/105634	773	// https://llvm.org/PR105634
771		774
772	string __name = chrono::__current_zone_environment();	775	string __name = chrono::__current_zone_environment();
773		776

lib/libcxx/src/filesystem/error.h+4-22

...	@@ -128,17 +128,8 @@ struct ErrorHandler {	...	@@ -128,17 +128,8 @@ struct ErrorHandler {
128	T report(const error_code& ec, const char* msg, ...) const {	128	T report(const error_code& ec, const char* msg, ...) const {
129	va_list ap;	129	va_list ap;
130	va_start(ap, msg);	130	va_start(ap, msg);
131	#if _LIBCPP_HAS_EXCEPTIONS	131	__scope_guard guard([&] { va_end(ap); });
132	try {	132	report_impl(ec, msg, ap);
133	#endif // _LIBCPP_HAS_EXCEPTIONS
134	report_impl(ec, msg, ap);
135	#if _LIBCPP_HAS_EXCEPTIONS
136	} catch (...) {
137	va_end(ap);
138	throw;
139	}
140	#endif // _LIBCPP_HAS_EXCEPTIONS
141	va_end(ap);
142	return error_value<T>();	133	return error_value<T>();
143	}	134	}
144		135
...	@@ -148,17 +139,8 @@ struct ErrorHandler {	...	@@ -148,17 +139,8 @@ struct ErrorHandler {
148	T report(errc const& err, const char* msg, ...) const {	139	T report(errc const& err, const char* msg, ...) const {
149	va_list ap;	140	va_list ap;
150	va_start(ap, msg);	141	va_start(ap, msg);
151	#if _LIBCPP_HAS_EXCEPTIONS	142	__scope_guard guard([&] { va_end(ap); });
152	try {	143	report_impl(make_error_code(err), msg, ap);
153	#endif // _LIBCPP_HAS_EXCEPTIONS
154	report_impl(make_error_code(err), msg, ap);
155	#if _LIBCPP_HAS_EXCEPTIONS
156	} catch (...) {
157	va_end(ap);
158	throw;
159	}
160	#endif // _LIBCPP_HAS_EXCEPTIONS
161	va_end(ap);
162	return error_value<T>();	144	return error_value<T>();
163	}	145	}
164		146

lib/libcxx/src/filesystem/format_string.h+9-18

 @@ -11,6 +11,7 @@
 #include <__assert>
 #include <__config>
+#include <__utility/scope_guard.h>
 #include <array>
 #include <cstdarg>
 #include <cstddef>
 @@ -34,20 +35,19 @@ inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 0) string vformat_string(const ch
   va_list apcopy;
   va_copy(apcopy, ap);
-  int ret = ::vsnprintf(buf.data(), buf.size(), msg, apcopy);
+  int size = ::vsnprintf(buf.data(), buf.size(), msg, apcopy);
   va_end(apcopy);
   string result;
-  if (static_cast<size_t>(ret) < buf.size()) {
+  if (static_cast<size_t>(size) < buf.size()) {
-    result.assign(buf.data(), static_cast<size_t>(ret));
+    result.assign(buf.data(), static_cast<size_t>(size));
   } else {
     // we did not provide a long enough buffer on our first attempt. The
     // return value is the number of bytes (excluding the null byte) that are
     // needed for formatting.
-    size_t size_with_null = static_cast<size_t>(ret) + 1;
+    result.resize_and_overwrite(size, [&](char* res, size_t n) { return ::vsnprintf(res, n, msg, ap); });
-    result.__resize_default_init(size_with_null - 1);
+    _LIBCPP_ASSERT_INTERNAL(static_cast<size_t>(size) == result.size(),
-    ret = ::vsnprintf(&result[0], size_with_null, msg, ap);
+                            "vsnprintf did not result in the same number of characters as the first attempt?");
-    _LIBCPP_ASSERT_INTERNAL(static_cast<size_t>(ret) == (size_with_null - 1), "TODO");
   }
   return result;
 }
 @@ -56,17 +56,8 @@ inline _LIBCPP_ATTRIBUTE_FORMAT(__printf__, 1, 2) string format_string(const cha
   string ret;
   va_list ap;
   va_start(ap, msg);
-#if _LIBCPP_HAS_EXCEPTIONS
+  __scope_guard guard([&] { va_end(ap); });
-  try {
+  ret = detail::vformat_string(msg, ap);
-#endif // _LIBCPP_HAS_EXCEPTIONS
-    ret = detail::vformat_string(msg, ap);
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    va_end(ap);
-    throw;
-  }
-#endif // _LIBCPP_HAS_EXCEPTIONS
-  va_end(ap);
   return ret;
 }

lib/libcxx/src/filesystem/int128_builtins.cpp+2

...	@@ -16,6 +16,8 @@	...	@@ -16,6 +16,8 @@
16	#include <__config>	16	#include <__config>
17	#include <climits>	17	#include <climits>
18		18
		19	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-prototypes") // See the FIXME above
		20
19	#if _LIBCPP_HAS_INT128	21	#if _LIBCPP_HAS_INT128
20		22
21	extern "C" __attribute__((no_sanitize("undefined"))) _LIBCPP_EXPORTED_FROM_ABI __int128_t	23	extern "C" __attribute__((no_sanitize("undefined"))) _LIBCPP_EXPORTED_FROM_ABI __int128_t

lib/libcxx/src/filesystem/operations.cpp+2-9

 @@ -41,17 +41,10 @@
 #include <time.h>
 // since Linux 4.5 and FreeBSD 13, but the Linux libc wrapper is only provided by glibc >= 2.27 and musl
-#if defined(__linux__)
+#if _LIBCPP_GLIBC_PREREQ(2, 27) || _LIBCPP_HAS_MUSL_LIBC || defined(__FreeBSD__)
-#  if defined(_LIBCPP_GLIBC_PREREQ)
-#    if _LIBCPP_GLIBC_PREREQ(2, 27)
-#      define _LIBCPP_FILESYSTEM_USE_COPY_FILE_RANGE
-#    endif
-#  elif _LIBCPP_HAS_MUSL_LIBC
-#    define _LIBCPP_FILESYSTEM_USE_COPY_FILE_RANGE
-#  endif
-#elif defined(__FreeBSD__)
 #  define _LIBCPP_FILESYSTEM_USE_COPY_FILE_RANGE
 #endif
 #if __has_include(<sys/sendfile.h>)
 #  include <sys/sendfile.h>
 #  define _LIBCPP_FILESYSTEM_USE_SENDFILE

lib/libcxx/src/filesystem/path.cpp+3-1

 @@ -292,7 +292,9 @@ path path::lexically_relative(const path& base) const {
   // return a path constructed with 'n' dot-dot elements, followed by the
   // elements of '*this' after the mismatch.
   path Result;
-  // FIXME: Reserve enough room in Result that it won't have to re-allocate.
+  constexpr size_t ElemSize      = 2; // ".."
+  constexpr size_t SeparatorSize = 1; // separator is always a single char
+  Result.__reserve(ElemCount * (ElemSize + SeparatorSize) + SeparatorSize + PP.Path.size());
   while (ElemCount--)
     Result /= PATHSTR("..");
   for (; PP; ++PP)

lib/libcxx/src/include/aligned_alloc.h created+65

...	@@ -0,0 +1,65 @@
1	//===----------------------------------------------------------------------===//
2	//
3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4	// See https://llvm.org/LICENSE.txt for license information.
5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6	//
7	//===----------------------------------------------------------------------===//
8
9	#ifndef _LIBCPP_SRC_ALIGNED_ALLOC_H
10	#define _LIBCPP_SRC_ALIGNED_ALLOC_H
11
12	#include <__config>
13	#include <cstdlib>
14
15	#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
16	# pragma GCC system_header
17	#endif
18
19	_LIBCPP_BEGIN_NAMESPACE_STD
20
21	#if _LIBCPP_HAS_LIBRARY_ALIGNED_ALLOCATION
22
23	// Low-level helpers to call the aligned allocation and deallocation functions
24	// on the target platform. This is used to implement libc++'s own memory
25	// allocation routines -- if you need to allocate memory inside the library,
26	// chances are that you want to use `__libcpp_allocate` instead.
27	//
28	// Returns the allocated memory, or `nullptr` on failure.
29	inline _LIBCPP_HIDE_FROM_ABI void* __libcpp_aligned_alloc(std::size_t __alignment, std::size_t __size) {
30	# if defined(_LIBCPP_MSVCRT_LIKE)
31	return ::_aligned_malloc(__size, __alignment);
32
33	// Android only provides aligned_alloc when targeting API 28 or higher.
34	# elif !defined(__ANDROID__) \|\| __ANDROID_API__ >= 28
35	// aligned_alloc() requires that __size is a multiple of __alignment,
36	// but for C++ [new.delete.general], only states "if the value of an
37	// alignment argument passed to any of these functions is not a valid
38	// alignment value, the behavior is undefined".
39	// To handle calls such as ::operator new(1, std::align_val_t(128)), we
40	// round __size up to the next multiple of __alignment.
41	size_t __rounded_size = (__size + __alignment - 1) & ~(__alignment - 1);
42	// Rounding up could have wrapped around to zero, so we have to add another
43	// max() ternary to the actual call site to avoid succeeded in that case.
44	return ::aligned_alloc(__alignment, __size > __rounded_size ? __size : __rounded_size);
45	# else
46	void* __result = nullptr;
47	(void)::posix_memalign(&__result, __alignment, __size);
48	// If posix_memalign fails, __result is unmodified so we still return `nullptr`.
49	return __result;
50	# endif
51	}
52
53	inline _LIBCPP_HIDE_FROM_ABI void __libcpp_aligned_free(void* __ptr) {
54	# if defined(_LIBCPP_MSVCRT_LIKE)
55	::_aligned_free(__ptr);
56	# else
57	::free(__ptr);
58	# endif
59	}
60
61	#endif // _LIBCPP_HAS_LIBRARY_ALIGNED_ALLOCATION
62
63	_LIBCPP_END_NAMESPACE_STD
64
65	#endif // _LIBCPP_SRC_ALIGNED_ALLOC_H

lib/libcxx/src/include/config_elast.h+1-1

...	@@ -23,7 +23,7 @@	...	@@ -23,7 +23,7 @@
23	# define _LIBCPP_ELAST ELAST	23	# define _LIBCPP_ELAST ELAST
24	#elif defined(__LLVM_LIBC__)	24	#elif defined(__LLVM_LIBC__)
25	// No _LIBCPP_ELAST needed for LLVM libc	25	// No _LIBCPP_ELAST needed for LLVM libc
26	#elif defined(_NEWLIB_VERSION)	26	#elif _LIBCPP_LIBC_NEWLIB
27	# define _LIBCPP_ELAST __ELASTERROR	27	# define _LIBCPP_ELAST __ELASTERROR
28	#elif defined(__NuttX__)	28	#elif defined(__NuttX__)
29	// No _LIBCPP_ELAST needed on NuttX	29	// No _LIBCPP_ELAST needed on NuttX

lib/libcxx/src/include/from_chars_floating_point.h+11-7

 @@ -9,11 +9,6 @@
 #ifndef _LIBCPP_SRC_INCLUDE_FROM_CHARS_FLOATING_POINT_H
 #define _LIBCPP_SRC_INCLUDE_FROM_CHARS_FLOATING_POINT_H
-// These headers are in the shared LLVM-libc header library.
-#include "shared/fp_bits.h"
-#include "shared/str_to_float.h"
-#include "shared/str_to_integer.h"
 #include <__assert>
 #include <__config>
 #include <cctype>
 @@ -21,6 +16,15 @@
 #include <concepts>
 #include <limits>
+// Make sure we use libc++'s assertion machinery within the shared code we use
+// from LLVM libc.
+#define LIBC_ASSERT(cond) _LIBCPP_ASSERT((cond), _LIBCPP_TOSTRING(cond))
+// These headers are in the shared LLVM-libc header library.
+#include "shared/fp_bits.h"
+#include "shared/str_to_float.h"
+#include "shared/str_to_integer.h"
 // Included for the _Floating_type_traits class
 #include "to_chars_floating_point.h"
 @@ -193,7 +197,7 @@ struct __exponent_result {
 // __offset, 0, false. This allows using the results unconditionally, the
 // __present is important for the scientific notation, where the value is
 // mandatory.
-__exponent_result __parse_exponent(const char* __input, size_t __n, size_t __offset, char __marker) {
+static __exponent_result __parse_exponent(const char* __input, size_t __n, size_t __offset, char __marker) {
   if (__offset + 1 < __n &&                          // an exponent always needs at least one digit.
       std::tolower(__input[__offset]) == __marker && //
       !std::isspace(__input[__offset + 1])           // leading whitespace is not allowed.
 @@ -213,7 +217,7 @@ __exponent_result __parse_exponent(const char* __input, size_t __n, size_t __off
 }
 // Here we do this operation as int64 to avoid overflow.
-int32_t __merge_exponents(int64_t __fractional, int64_t __exponent, int __max_biased_exponent) {
+static int32_t __merge_exponents(int64_t __fractional, int64_t __exponent, int __max_biased_exponent) {
   int64_t __sum = __fractional + __exponent;
   if (__sum > __max_biased_exponent)

lib/libcxx/src/include/overridable_function.h+8-10

 @@ -29,12 +29,12 @@
 // This is a low-level utility which does not work on all platforms, since it needs
 // to make assumptions about the object file format in use. Furthermore, it requires
 // the "base definition" of the function (the one we want to check whether it has been
-// overridden) to be defined using the _LIBCPP_OVERRIDABLE_FUNCTION macro.
+// overridden) to be defined using the OVERRIDABLE_FUNCTION macro.
 //
 // This currently works with Mach-O files (used on Darwin) and with ELF files (used on Linux
 // and others). On platforms where we know how to implement this detection, the macro
 // _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION is defined to 1, and it is defined to 0 on
-// other platforms. The _LIBCPP_OVERRIDABLE_FUNCTION macro is defined to perform a normal
+// other platforms. The OVERRIDABLE_FUNCTION macro is defined to perform a normal
 // function definition on unsupported platforms so that it can be used to define functions
 // regardless of whether detection is actually supported.
 //
 @@ -44,7 +44,7 @@
 // Let's say we want to check whether a weak function `f` has been overridden by the user.
 // The general mechanism works by placing `f`'s definition (in the libc++ built library)
 // inside a special section, which we do using the `__section__` attribute via the
-// _LIBCPP_OVERRIDABLE_FUNCTION macro.
+// OVERRIDABLE_FUNCTION macro.
 //
 // Then, when comes the time to check whether the function has been overridden, we take
 // the address of the function and we check whether it falls inside the special function
 @@ -66,11 +66,10 @@
 #if defined(_LIBCPP_OBJECT_FORMAT_MACHO)
 #  define _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION 1
-#  define _LIBCPP_OVERRIDABLE_FUNCTION(type, name, arglist)                                                            \
+#  define OVERRIDABLE_FUNCTION                                                                                         \
-    __attribute__((__section__("__TEXT,__lcxx_override,regular,pure_instructions"))) _LIBCPP_WEAK type name arglist
+    __attribute__((__section__("__TEXT,__lcxx_override,regular,pure_instructions"))) _LIBCPP_WEAK
-_LIBCPP_BEGIN_NAMESPACE_STD
+_LIBCPP_BEGIN_NAMESPACE_STD template <typename T, T* _Func>
-template <typename T, T* _Func>
 _LIBCPP_HIDE_FROM_ABI inline bool __is_function_overridden() noexcept {
   // Declare two dummy bytes and give them these special `__asm` values. These values are
   // defined by the linker, which means that referring to `&__lcxx_override_start` will
 @@ -100,8 +99,7 @@ _LIBCPP_END_NAMESPACE_STD
 #elif defined(_LIBCPP_OBJECT_FORMAT_ELF) && !defined(__NVPTX__)
 #  define _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION 1
-#  define _LIBCPP_OVERRIDABLE_FUNCTION(type, name, arglist)                                                            \
+#  define OVERRIDABLE_FUNCTION __attribute__((__section__("__lcxx_override"))) _LIBCPP_WEAK
-    __attribute__((__section__("__lcxx_override"))) _LIBCPP_WEAK type name arglist
 // This is very similar to what we do for Mach-O above. The ELF linker will implicitly define
 // variables with those names corresponding to the start and the end of the section.
 @@ -129,7 +127,7 @@ _LIBCPP_END_NAMESPACE_STD
 #else
 #  define _LIBCPP_CAN_DETECT_OVERRIDDEN_FUNCTION 0
-#  define _LIBCPP_OVERRIDABLE_FUNCTION(type, name, arglist) _LIBCPP_WEAK type name arglist
+#  define OVERRIDABLE_FUNCTION _LIBCPP_WEAK
 #endif

lib/libcxx/src/iostream.cpp+56-37

 @@ -16,24 +16,40 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
+// This file implements the various stream objects provided inside <iostream>. We're doing some ODR violations in here,
+// so this quite fragile. Specifically, the size of the stream objects (i.e. cout, cin etc.) needs to stay the same.
+// For that reason, we have `stream` and `stream_data` separated into two objects. The public `stream` objects only
+// contain the actual stream, while the private `stream_data` objects contains the `basic_streambuf` we're using as well
+// as the mbstate_t. `stream_data` objects are only accessible within the library, so they aren't ABI sensitive and we
+// can change them as we want.
+template <class StreamT>
+union stream {
+  constexpr stream() {}
+  stream(const stream&)            = delete;
+  stream& operator=(const stream&) = delete;
+  constexpr ~stream() {}
+  StreamT value;
+};
 template <class StreamT, class BufferT>
 union stream_data {
   constexpr stream_data() {}
   constexpr ~stream_data() {}
   struct {
-    // The stream has to be the first element, since that's referenced by the stream declarations in <iostream>
-    StreamT stream;
     BufferT buffer;
     mbstate_t mb;
   };
-  void init(FILE* stdstream) {
-    mb = {};
-    std::construct_at(&buffer, stdstream, &mb);
-    std::construct_at(&stream, &buffer);
-  }
 };
+template <class StreamT, class BufferT>
+void init_stream(FILE* stdstream, stream<StreamT>& stream, stream_data<StreamT, BufferT>& data) {
+  data.mb = {};
+  std::construct_at(&data.buffer, stdstream, &data.mb);
+  std::construct_at(&stream.value, &data.buffer);
+}
 #define CHAR_MANGLING_char "D"
 #define CHAR_MANGLING_wchar_t "_W"
 #define CHAR_MANGLING(CharT) CHAR_MANGLING_##CharT
 @@ -46,25 +62,28 @@ union stream_data {
 #ifdef _LIBCPP_ABI_MICROSOFT
 #  define STREAM(StreamT, BufferT, CharT, var)                                                                         \
-    STRING_DATA_CONSTINIT stream_data<StreamT<CharT>, BufferT<CharT>> var __asm__(                                     \
+    STRING_DATA_CONSTINIT stream_data<StreamT<CharT>, BufferT<CharT>> var##_data;                                      \
+    _LIBCPP_EXPORTED_FROM_ABI STRING_DATA_CONSTINIT stream<StreamT<CharT>> var __asm__(                                \
         "?" #var "@" ABI_NAMESPACE_STR "@std@@3V?$" #StreamT                                                           \
         "@" CHAR_MANGLING(CharT) "U?$char_traits@" CHAR_MANGLING(CharT) "@" ABI_NAMESPACE_STR "@std@@@12@A")
 #else
-#  define STREAM(StreamT, BufferT, CharT, var) STRING_DATA_CONSTINIT stream_data<StreamT<CharT>, BufferT<CharT>> var
+#  define STREAM(StreamT, BufferT, CharT, var)                                                                         \
+    STRING_DATA_CONSTINIT stream_data<StreamT<CharT>, BufferT<CharT>> var##_data;                                      \
+    _LIBCPP_EXPORTED_FROM_ABI STRING_DATA_CONSTINIT stream<StreamT<CharT>> var
 #endif
 // These definitions and the declarations in <iostream> technically cause ODR violations, since they have different
 // types (stream_data and {i,o}stream respectively). This means that <iostream> should never be included in this TU.
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_istream, __stdinbuf, char, cin);
+STREAM(basic_istream, __stdinbuf, char, cin);
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_ostream, __stdoutbuf, char, cout);
+STREAM(basic_ostream, __stdoutbuf, char, cout);
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_ostream, __stdoutbuf, char, cerr);
+STREAM(basic_ostream, __stdoutbuf, char, cerr);
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_ostream, __stdoutbuf, char, clog);
+STREAM(basic_ostream, __stdoutbuf, char, clog);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_istream, __stdinbuf, wchar_t, wcin);
+STREAM(basic_istream, __stdinbuf, wchar_t, wcin);
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_ostream, __stdoutbuf, wchar_t, wcout);
+STREAM(basic_ostream, __stdoutbuf, wchar_t, wcout);
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_ostream, __stdoutbuf, wchar_t, wcerr);
+STREAM(basic_ostream, __stdoutbuf, wchar_t, wcerr);
-_LIBCPP_EXPORTED_FROM_ABI STREAM(basic_ostream, __stdoutbuf, wchar_t, wclog);
+STREAM(basic_ostream, __stdoutbuf, wchar_t, wclog);
 #endif // _LIBCPP_HAS_WIDE_CHARACTERS
 // Pretend we're inside a system header so the compiler doesn't flag the use of the init_priority
 @@ -98,34 +117,34 @@ public:
 DoIOSInit::DoIOSInit() {
   force_locale_initialization();
-  cin.init(stdin);
+  init_stream(stdin, cin, cin_data);
-  cout.init(stdout);
+  init_stream(stdout, cout, cout_data);
-  cerr.init(stderr);
+  init_stream(stderr, cerr, cerr_data);
-  clog.init(stderr);
+  init_stream(stderr, clog, clog_data);
-  cin.stream.tie(&cout.stream);
+  cin.value.tie(&cout.value);
-  std::unitbuf(cerr.stream);
+  std::unitbuf(cerr.value);
-  cerr.stream.tie(&cout.stream);
+  cerr.value.tie(&cout.value);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-  wcin.init(stdin);
+  init_stream(stdin, wcin, wcin_data);
-  wcout.init(stdout);
+  init_stream(stdout, wcout, wcout_data);
-  wcerr.init(stderr);
+  init_stream(stderr, wcerr, wcerr_data);
-  wclog.init(stderr);
+  init_stream(stderr, wclog, wclog_data);
-  wcin.stream.tie(&wcout.stream);
+  wcin.value.tie(&wcout.value);
-  std::unitbuf(wcerr.stream);
+  std::unitbuf(wcerr.value);
-  wcerr.stream.tie(&wcout.stream);
+  wcerr.value.tie(&wcout.value);
 #endif
 }
 DoIOSInit::~DoIOSInit() {
-  cout.stream.flush();
+  cout.value.flush();
-  clog.stream.flush();
+  clog.value.flush();
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-  wcout.stream.flush();
+  wcout.value.flush();
-  wclog.stream.flush();
+  wclog.value.flush();
 #endif
 }

lib/libcxx/src/locale.cpp+213-196

 @@ -60,9 +60,8 @@ struct __libcpp_unique_locale {
   __locale::__locale_t __loc_;
-private:
+  __libcpp_unique_locale(__libcpp_unique_locale const&) = delete;
-  __libcpp_unique_locale(__libcpp_unique_locale const&);
+  __libcpp_unique_locale& operator=(__libcpp_unique_locale const&) = delete;
-  __libcpp_unique_locale& operator=(__libcpp_unique_locale const&);
 };
 #ifdef __cloc_defined
 @@ -88,16 +87,6 @@ T& make(Args... args) {
   return *obj;
 }
-template <typename T, size_t N>
-inline constexpr size_t countof(const T (&)[N]) {
-  return N;
-}
-template <typename T>
-inline constexpr size_t countof(const T* const begin, const T* const end) {
-  return static_cast<size_t>(end - begin);
-}
 string build_name(const string& other, const string& one, locale::category c) {
   if (other == "*" || one == "*")
     return "*";
 @@ -215,63 +204,58 @@ locale::__imp::__imp(size_t refs) : facet(refs), facets_(N), name_("C") {
 }
 locale::__imp::__imp(const string& name, size_t refs) : facet(refs), facets_(N), name_(name) {
-#if _LIBCPP_HAS_EXCEPTIONS
+  __exception_guard guard([&] {
-  try {
-#endif // _LIBCPP_HAS_EXCEPTIONS
-    facets_ = locale::classic().__locale_->facets_;
     for (unsigned i = 0; i < facets_.size(); ++i)
       if (facets_[i])
-        facets_[i]->__add_shared();
+        facets_[i]->__release_shared();
-    install(new collate_byname<char>(name_));
+  });
+  facets_ = locale::classic().__locale_->facets_;
+  for (unsigned i = 0; i < facets_.size(); ++i)
+    if (facets_[i])
+      facets_[i]->__add_shared();
+  install(new collate_byname<char>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new collate_byname<wchar_t>(name_));
+  install(new collate_byname<wchar_t>(name_));
 #endif
-    install(new ctype_byname<char>(name_));
+  install(new ctype_byname<char>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new ctype_byname<wchar_t>(name_));
+  install(new ctype_byname<wchar_t>(name_));
 #endif
-    install(new codecvt_byname<char, char, mbstate_t>(name_));
+  install(new codecvt_byname<char, char, mbstate_t>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
+  install(new codecvt_byname<wchar_t, char, mbstate_t>(name_));
 #endif
-    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+  _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-    install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
+  install(new codecvt_byname<char16_t, char, mbstate_t>(name_));
-    install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
+  install(new codecvt_byname<char32_t, char, mbstate_t>(name_));
-    _LIBCPP_SUPPRESS_DEPRECATED_POP
+  _LIBCPP_SUPPRESS_DEPRECATED_POP
 #if _LIBCPP_HAS_CHAR8_T
-    install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_));
+  install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name_));
-    install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_));
+  install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name_));
 #endif
-    install(new numpunct_byname<char>(name_));
+  install(new numpunct_byname<char>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new numpunct_byname<wchar_t>(name_));
+  install(new numpunct_byname<wchar_t>(name_));
 #endif
-    install(new moneypunct_byname<char, false>(name_));
+  install(new moneypunct_byname<char, false>(name_));
-    install(new moneypunct_byname<char, true>(name_));
+  install(new moneypunct_byname<char, true>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new moneypunct_byname<wchar_t, false>(name_));
+  install(new moneypunct_byname<wchar_t, false>(name_));
-    install(new moneypunct_byname<wchar_t, true>(name_));
+  install(new moneypunct_byname<wchar_t, true>(name_));
 #endif
-    install(new time_get_byname<char>(name_));
+  install(new time_get_byname<char>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new time_get_byname<wchar_t>(name_));
+  install(new time_get_byname<wchar_t>(name_));
 #endif
-    install(new time_put_byname<char>(name_));
+  install(new time_put_byname<char>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new time_put_byname<wchar_t>(name_));
+  install(new time_put_byname<wchar_t>(name_));
 #endif
-    install(new messages_byname<char>(name_));
+  install(new messages_byname<char>(name_));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-    install(new messages_byname<wchar_t>(name_));
+  install(new messages_byname<wchar_t>(name_));
 #endif
-#if _LIBCPP_HAS_EXCEPTIONS
+  guard.__complete();
-  } catch (...) {
-    for (unsigned i = 0; i < facets_.size(); ++i)
-      if (facets_[i])
-        facets_[i]->__release_shared();
-    throw;
-  }
-#endif // _LIBCPP_HAS_EXCEPTIONS
 }
 locale::__imp::__imp(const __imp& other) : facets_(max<size_t>(N, other.facets_.size())), name_(other.name_) {
 @@ -287,71 +271,66 @@ locale::__imp::__imp(const __imp& other, const string& name, locale::category c)
   for (unsigned i = 0; i < facets_.size(); ++i)
     if (facets_[i])
       facets_[i]->__add_shared();
-#if _LIBCPP_HAS_EXCEPTIONS
+  __exception_guard guard([&] {
-  try {
+    for (unsigned i = 0; i < facets_.size(); ++i)
-#endif // _LIBCPP_HAS_EXCEPTIONS
+      if (facets_[i])
-    if (c & locale::collate) {
+        facets_[i]->__release_shared();
-      install(new collate_byname<char>(name));
+  });
+  if (c & locale::collate) {
+    install(new collate_byname<char>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new collate_byname<wchar_t>(name));
+    install(new collate_byname<wchar_t>(name));
 #endif
-    }
+  }
-    if (c & locale::ctype) {
+  if (c & locale::ctype) {
-      install(new ctype_byname<char>(name));
+    install(new ctype_byname<char>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new ctype_byname<wchar_t>(name));
+    install(new ctype_byname<wchar_t>(name));
 #endif
-      install(new codecvt_byname<char, char, mbstate_t>(name));
+    install(new codecvt_byname<char, char, mbstate_t>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
+    install(new codecvt_byname<wchar_t, char, mbstate_t>(name));
 #endif
-      _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-      install(new codecvt_byname<char16_t, char, mbstate_t>(name));
+    install(new codecvt_byname<char16_t, char, mbstate_t>(name));
-      install(new codecvt_byname<char32_t, char, mbstate_t>(name));
+    install(new codecvt_byname<char32_t, char, mbstate_t>(name));
-      _LIBCPP_SUPPRESS_DEPRECATED_POP
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
 #if _LIBCPP_HAS_CHAR8_T
-      install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name));
+    install(new codecvt_byname<char16_t, char8_t, mbstate_t>(name));
-      install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name));
+    install(new codecvt_byname<char32_t, char8_t, mbstate_t>(name));
 #endif
-    }
+  }
-    if (c & locale::monetary) {
+  if (c & locale::monetary) {
-      install(new moneypunct_byname<char, false>(name));
+    install(new moneypunct_byname<char, false>(name));
-      install(new moneypunct_byname<char, true>(name));
+    install(new moneypunct_byname<char, true>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new moneypunct_byname<wchar_t, false>(name));
+    install(new moneypunct_byname<wchar_t, false>(name));
-      install(new moneypunct_byname<wchar_t, true>(name));
+    install(new moneypunct_byname<wchar_t, true>(name));
 #endif
-    }
+  }
-    if (c & locale::numeric) {
+  if (c & locale::numeric) {
-      install(new numpunct_byname<char>(name));
+    install(new numpunct_byname<char>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new numpunct_byname<wchar_t>(name));
+    install(new numpunct_byname<wchar_t>(name));
 #endif
-    }
+  }
-    if (c & locale::time) {
+  if (c & locale::time) {
-      install(new time_get_byname<char>(name));
+    install(new time_get_byname<char>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new time_get_byname<wchar_t>(name));
+    install(new time_get_byname<wchar_t>(name));
 #endif
-      install(new time_put_byname<char>(name));
+    install(new time_put_byname<char>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new time_put_byname<wchar_t>(name));
+    install(new time_put_byname<wchar_t>(name));
 #endif
-    }
+  }
-    if (c & locale::messages) {
+  if (c & locale::messages) {
-      install(new messages_byname<char>(name));
+    install(new messages_byname<char>(name));
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install(new messages_byname<wchar_t>(name));
+    install(new messages_byname<wchar_t>(name));
 #endif
-    }
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    for (unsigned i = 0; i < facets_.size(); ++i)
-      if (facets_[i])
-        facets_[i]->__release_shared();
-    throw;
   }
-#endif // _LIBCPP_HAS_EXCEPTIONS
+  guard.__complete();
 }
 template <class F>
 @@ -366,87 +345,83 @@ locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
   for (unsigned i = 0; i < facets_.size(); ++i)
     if (facets_[i])
       facets_[i]->__add_shared();
-#if _LIBCPP_HAS_EXCEPTIONS
+  __exception_guard guard([&] {
-  try {
+    for (unsigned i = 0; i < facets_.size(); ++i)
-#endif // _LIBCPP_HAS_EXCEPTIONS
+      if (facets_[i])
-    if (c & locale::collate) {
+        facets_[i]->__release_shared();
-      install_from<std::collate<char> >(one);
+  });
+  if (c & locale::collate) {
+    install_from<std::collate<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<std::collate<wchar_t> >(one);
+    install_from<std::collate<wchar_t> >(one);
 #endif
-    }
+  }
-    if (c & locale::ctype) {
+  if (c & locale::ctype) {
-      install_from<std::ctype<char> >(one);
+    install_from<std::ctype<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<std::ctype<wchar_t> >(one);
+    install_from<std::ctype<wchar_t> >(one);
 #endif
-      install_from<std::codecvt<char, char, mbstate_t> >(one);
+    install_from<std::codecvt<char, char, mbstate_t> >(one);
-      _LIBCPP_SUPPRESS_DEPRECATED_PUSH
+    _LIBCPP_SUPPRESS_DEPRECATED_PUSH
-      install_from<std::codecvt<char16_t, char, mbstate_t> >(one);
+    install_from<std::codecvt<char16_t, char, mbstate_t> >(one);
-      install_from<std::codecvt<char32_t, char, mbstate_t> >(one);
+    install_from<std::codecvt<char32_t, char, mbstate_t> >(one);
-      _LIBCPP_SUPPRESS_DEPRECATED_POP
+    _LIBCPP_SUPPRESS_DEPRECATED_POP
 #if _LIBCPP_HAS_CHAR8_T
-      install_from<std::codecvt<char16_t, char8_t, mbstate_t> >(one);
+    install_from<std::codecvt<char16_t, char8_t, mbstate_t> >(one);
-      install_from<std::codecvt<char32_t, char8_t, mbstate_t> >(one);
+    install_from<std::codecvt<char32_t, char8_t, mbstate_t> >(one);
 #endif
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<std::codecvt<wchar_t, char, mbstate_t> >(one);
+    install_from<std::codecvt<wchar_t, char, mbstate_t> >(one);
 #endif
-    }
+  }
-    if (c & locale::monetary) {
+  if (c & locale::monetary) {
-      install_from<moneypunct<char, false> >(one);
+    install_from<moneypunct<char, false> >(one);
-      install_from<moneypunct<char, true> >(one);
+    install_from<moneypunct<char, true> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<moneypunct<wchar_t, false> >(one);
+    install_from<moneypunct<wchar_t, false> >(one);
-      install_from<moneypunct<wchar_t, true> >(one);
+    install_from<moneypunct<wchar_t, true> >(one);
 #endif
-      install_from<money_get<char> >(one);
+    install_from<money_get<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<money_get<wchar_t> >(one);
+    install_from<money_get<wchar_t> >(one);
 #endif
-      install_from<money_put<char> >(one);
+    install_from<money_put<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<money_put<wchar_t> >(one);
+    install_from<money_put<wchar_t> >(one);
 #endif
-    }
+  }
-    if (c & locale::numeric) {
+  if (c & locale::numeric) {
-      install_from<numpunct<char> >(one);
+    install_from<numpunct<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<numpunct<wchar_t> >(one);
+    install_from<numpunct<wchar_t> >(one);
 #endif
-      install_from<num_get<char> >(one);
+    install_from<num_get<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<num_get<wchar_t> >(one);
+    install_from<num_get<wchar_t> >(one);
 #endif
-      install_from<num_put<char> >(one);
+    install_from<num_put<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<num_put<wchar_t> >(one);
+    install_from<num_put<wchar_t> >(one);
 #endif
-    }
+  }
-    if (c & locale::time) {
+  if (c & locale::time) {
-      install_from<time_get<char> >(one);
+    install_from<time_get<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<time_get<wchar_t> >(one);
+    install_from<time_get<wchar_t> >(one);
 #endif
-      install_from<time_put<char> >(one);
+    install_from<time_put<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<time_put<wchar_t> >(one);
+    install_from<time_put<wchar_t> >(one);
 #endif
-    }
+  }
-    if (c & locale::messages) {
+  if (c & locale::messages) {
-      install_from<std::messages<char> >(one);
+    install_from<std::messages<char> >(one);
 #if _LIBCPP_HAS_WIDE_CHARACTERS
-      install_from<std::messages<wchar_t> >(one);
+    install_from<std::messages<wchar_t> >(one);
 #endif
-    }
-#if _LIBCPP_HAS_EXCEPTIONS
-  } catch (...) {
-    for (unsigned i = 0; i < facets_.size(); ++i)
-      if (facets_[i])
-        facets_[i]->__release_shared();
-    throw;
   }
-#endif // _LIBCPP_HAS_EXCEPTIONS
+  guard.__complete();
 }
 locale::__imp::__imp(const __imp& other, facet* f, long id)
 @@ -933,7 +908,7 @@ const ctype<char>::mask* ctype<char>::classic_table() noexcept {
   return __pctype_func();
 #  elif defined(__EMSCRIPTEN__)
   return *__ctype_b_loc();
-#  elif defined(_NEWLIB_VERSION)
+#  elif _LIBCPP_LIBC_NEWLIB
   // Newlib has a 257-entry table in ctype_.c, where (char)0 starts at [1].
   return _ctype_ + 1;
 #  elif defined(_AIX)
 @@ -3961,13 +3936,7 @@ wstring numpunct<wchar_t>::do_falsename() const { return L"false"; }
 // numpunct_byname<char>
-numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs) : numpunct<char>(refs) { __init(nm); }
+numpunct_byname<char>::numpunct_byname(const char* nm, size_t refs) : numpunct<char>(refs) {
-numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs) : numpunct<char>(refs) { __init(nm.c_str()); }
-numpunct_byname<char>::~numpunct_byname() {}
-void numpunct_byname<char>::__init(const char* nm) {
   typedef numpunct<char> base;
   if (strcmp(nm, "C") != 0) {
     __libcpp_unique_locale loc(nm);
 @@ -3988,18 +3957,14 @@ void numpunct_byname<char>::__init(const char* nm) {
   }
 }
-// numpunct_byname<wchar_t>
+numpunct_byname<char>::numpunct_byname(const string& nm, size_t refs) : numpunct_byname<char>(nm.c_str(), refs) {}
-#if _LIBCPP_HAS_WIDE_CHARACTERS
-numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs) : numpunct<wchar_t>(refs) { __init(nm); }
-numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs) : numpunct<wchar_t>(refs) {
+numpunct_byname<char>::~numpunct_byname() {}
-  __init(nm.c_str());
-}
-numpunct_byname<wchar_t>::~numpunct_byname() {}
+// numpunct_byname<wchar_t>
-void numpunct_byname<wchar_t>::__init(const char* nm) {
+#if _LIBCPP_HAS_WIDE_CHARACTERS
+numpunct_byname<wchar_t>::numpunct_byname(const char* nm, size_t refs) : numpunct<wchar_t>(refs) {
   if (strcmp(nm, "C") != 0) {
     __libcpp_unique_locale loc(nm);
     if (!loc)
 @@ -4016,6 +3981,10 @@ void numpunct_byname<wchar_t>::__init(const char* nm) {
     // localization for truename and falsename is not available
   }
 }
+numpunct_byname<wchar_t>::numpunct_byname(const string& nm, size_t refs) : numpunct_byname<wchar_t>(nm.c_str(), refs) {}
+numpunct_byname<wchar_t>::~numpunct_byname() {}
 #endif // _LIBCPP_HAS_WIDE_CHARACTERS
 // num_get helpers
 @@ -4383,7 +4352,7 @@ string __time_get_storage<char>::__analyze(char fmt, const ctype<char>& ct) {
   char f[3] = {0};
   f[0]      = '%';
   f[1]      = fmt;
-  size_t n  = __locale::__strftime(buf, countof(buf), f, &t, __loc_);
+  size_t n  = __locale::__strftime(buf, std::size(buf), f, &t, __loc_);
   char* bb  = buf;
   char* be  = buf + n;
   string result;
 @@ -4514,12 +4483,12 @@ wstring __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& c
   char f[3] = {0};
   f[0]      = '%';
   f[1]      = fmt;
-  __locale::__strftime(buf, countof(buf), f, &t, __loc_);
+  __locale::__strftime(buf, std::size(buf), f, &t, __loc_);
   wchar_t wbuf[100];
   wchar_t* wbb   = wbuf;
   mbstate_t mb   = {0};
   const char* bb = buf;
-  size_t j       = __locale::__mbsrtowcs(wbb, &bb, countof(wbuf), &mb, __loc_);
+  size_t j       = __locale::__mbsrtowcs(wbb, &bb, std::size(wbuf), &mb, __loc_);
   if (j == size_t(-1))
     std::__throw_runtime_error("locale not supported");
   wchar_t* wbe = wbb + j;
 @@ -4640,25 +4609,25 @@ void __time_get_storage<char>::init(const ctype<char>& ct) {
   // __weeks_
   for (int i = 0; i < 7; ++i) {
     t.tm_wday = i;
-    __locale::__strftime(buf, countof(buf), "%A", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%A", &t, __loc_);
     __weeks_[i] = buf;
-    __locale::__strftime(buf, countof(buf), "%a", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%a", &t, __loc_);
     __weeks_[i + 7] = buf;
   }
   // __months_
   for (int i = 0; i < 12; ++i) {
     t.tm_mon = i;
-    __locale::__strftime(buf, countof(buf), "%B", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%B", &t, __loc_);
     __months_[i] = buf;
-    __locale::__strftime(buf, countof(buf), "%b", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%b", &t, __loc_);
     __months_[i + 12] = buf;
   }
   // __am_pm_
   t.tm_hour = 1;
-  __locale::__strftime(buf, countof(buf), "%p", &t, __loc_);
+  __locale::__strftime(buf, std::size(buf), "%p", &t, __loc_);
   __am_pm_[0] = buf;
   t.tm_hour   = 13;
-  __locale::__strftime(buf, countof(buf), "%p", &t, __loc_);
+  __locale::__strftime(buf, std::size(buf), "%p", &t, __loc_);
   __am_pm_[1] = buf;
   __c_        = __analyze('c', ct);
   __r_        = __analyze('r', ct);
 @@ -4677,18 +4646,18 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
   // __weeks_
   for (int i = 0; i < 7; ++i) {
     t.tm_wday = i;
-    __locale::__strftime(buf, countof(buf), "%A", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%A", &t, __loc_);
     mb             = mbstate_t();
     const char* bb = buf;
-    size_t j       = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    size_t j       = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, __loc_);
     if (j == size_t(-1) || j == 0)
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
     __weeks_[i].assign(wbuf, wbe);
-    __locale::__strftime(buf, countof(buf), "%a", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%a", &t, __loc_);
     mb = mbstate_t();
     bb = buf;
-    j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, __loc_);
     if (j == size_t(-1) || j == 0)
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
 @@ -4697,18 +4666,18 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
   // __months_
   for (int i = 0; i < 12; ++i) {
     t.tm_mon = i;
-    __locale::__strftime(buf, countof(buf), "%B", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%B", &t, __loc_);
     mb             = mbstate_t();
     const char* bb = buf;
-    size_t j       = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    size_t j       = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, __loc_);
     if (j == size_t(-1) || j == 0)
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
     __months_[i].assign(wbuf, wbe);
-    __locale::__strftime(buf, countof(buf), "%b", &t, __loc_);
+    __locale::__strftime(buf, std::size(buf), "%b", &t, __loc_);
     mb = mbstate_t();
     bb = buf;
-    j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
+    j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, __loc_);
     if (j == size_t(-1) || j == 0)
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
 @@ -4716,19 +4685,19 @@ void __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct) {
   }
   // __am_pm_
   t.tm_hour = 1;
-  __locale::__strftime(buf, countof(buf), "%p", &t, __loc_);
+  __locale::__strftime(buf, std::size(buf), "%p", &t, __loc_);
   mb             = mbstate_t();
   const char* bb = buf;
-  size_t j       = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
+  size_t j       = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, __loc_);
   if (j == size_t(-1))
     std::__throw_runtime_error("locale not supported");
   wbe = wbuf + j;
   __am_pm_[0].assign(wbuf, wbe);
   t.tm_hour = 13;
-  __locale::__strftime(buf, countof(buf), "%p", &t, __loc_);
+  __locale::__strftime(buf, std::size(buf), "%p", &t, __loc_);
   mb = mbstate_t();
   bb = buf;
-  j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, __loc_);
+  j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, __loc_);
   if (j == size_t(-1))
     std::__throw_runtime_error("locale not supported");
   wbe = wbuf + j;
 @@ -4957,7 +4926,7 @@ void __time_put::__do_put(char* __nb, char*& __ne, const tm* __tm, char __fmt, c
   char fmt[] = {'%', __fmt, __mod, 0};
   if (__mod != 0)
     swap(fmt[1], fmt[2]);
-  size_t n = __locale::__strftime(__nb, countof(__nb, __ne), fmt, __tm, __loc_);
+  size_t n = __locale::__strftime(__nb, std::distance(__nb, __ne), fmt, __tm, __loc_);
   __ne     = __nb + n;
 }
 @@ -4968,7 +4937,7 @@ void __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm, char __
   __do_put(__nar, __ne, __tm, __fmt, __mod);
   mbstate_t mb     = {0};
   const char* __nb = __nar;
-  size_t j         = __locale::__mbsrtowcs(__wb, &__nb, countof(__wb, __we), &mb, __loc_);
+  size_t j         = __locale::__mbsrtowcs(__wb, &__nb, std::distance(__wb, __we), &mb, __loc_);
   if (j == size_t(-1))
     std::__throw_runtime_error("locale not supported");
   __we = __wb + j;
 @@ -5443,7 +5412,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
   wchar_t wbuf[100];
   mbstate_t mb   = {0};
   const char* bb = lc->currency_symbol;
-  size_t j       = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
+  size_t j       = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, loc.get());
   if (j == size_t(-1))
     std::__throw_runtime_error("locale not supported");
   wchar_t* wbe = wbuf + j;
 @@ -5457,7 +5426,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
   else {
     mb = mbstate_t();
     bb = lc->positive_sign;
-    j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, loc.get());
     if (j == size_t(-1))
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
 @@ -5468,7 +5437,7 @@ void moneypunct_byname<wchar_t, false>::init(const char* nm) {
   else {
     mb = mbstate_t();
     bb = lc->negative_sign;
-    j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, loc.get());
     if (j == size_t(-1))
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
 @@ -5498,7 +5467,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
   wchar_t wbuf[100];
   mbstate_t mb   = {0};
   const char* bb = lc->int_curr_symbol;
-  size_t j       = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
+  size_t j       = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, loc.get());
   if (j == size_t(-1))
     std::__throw_runtime_error("locale not supported");
   wchar_t* wbe = wbuf + j;
 @@ -5516,7 +5485,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
   else {
     mb = mbstate_t();
     bb = lc->positive_sign;
-    j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, loc.get());
     if (j == size_t(-1))
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
 @@ -5531,7 +5500,7 @@ void moneypunct_byname<wchar_t, true>::init(const char* nm) {
   else {
     mb = mbstate_t();
     bb = lc->negative_sign;
-    j  = __locale::__mbsrtowcs(wbuf, &bb, countof(wbuf), &mb, loc.get());
+    j  = __locale::__mbsrtowcs(wbuf, &bb, std::size(wbuf), &mb, loc.get());
     if (j == size_t(-1))
       std::__throw_runtime_error("locale not supported");
     wbe = wbuf + j;
 @@ -5571,6 +5540,54 @@ string __num_get<_CharT>::__stage2_int_prep(ios_base& __iob, _CharT* __atoms, _C
   return __np.grouping();
 }
+template <class _CharT>
+int __num_get<_CharT>::__stage2_int_loop(
+    _CharT __ct,
+    int __base,
+    char* __a,
+    char*& __a_end,
+    unsigned& __dc,
+    _CharT __thousands_sep,
+    const string& __grouping,
+    unsigned* __g,
+    unsigned*& __g_end,
+    _CharT* __atoms) {
+  if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25])) {
+    *__a_end++ = __ct == __atoms[24] ? '+' : '-';
+    __dc       = 0;
+    return 0;
+  }
+  if (__grouping.size() != 0 && __ct == __thousands_sep) {
+    if (__g_end - __g < __num_get_buf_sz) {
+      *__g_end++ = __dc;
+      __dc       = 0;
+    }
+    return 0;
+  }
+  ptrdiff_t __f = __atoms_offset(__atoms, __ct);
+  if (__f >= 24)
+    return -1;
+  switch (__base) {
+  case 8:
+  case 10:
+    if (__f >= __base)
+      return -1;
+    break;
+  case 16:
+    if (__f < 22)
+      break;
+    if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0') {
+      __dc       = 0;
+      *__a_end++ = __src[__f];
+      return 0;
+    }
+    return -1;
+  }
+  *__a_end++ = __src[__f];
+  ++__dc;
+  return 0;
+}
 template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<char>;
 _LIBCPP_IF_WIDE_CHARACTERS(template class _LIBCPP_CLASS_TEMPLATE_INSTANTIATION_VIS collate<wchar_t>;)

lib/libcxx/src/memory.cpp+12-14

...	@@ -7,7 +7,8 @@	...	@@ -7,7 +7,8 @@
7	//===----------------------------------------------------------------------===//	7	//===----------------------------------------------------------------------===//
8		8
9	#include <__config>	9	#include <__config>
10	#ifdef _LIBCPP_DEPRECATED_ABI_LEGACY_LIBRARY_DEFINITIONS_FOR_INLINE_FUNCTIONS	10	#if !defined(_LIBCPP_OBJECT_FORMAT_COFF) && !defined(_LIBCPP_OBJECT_FORMAT_XCOFF) && \
		11	_LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 5
11	# define _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS	12	# define _LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS
12	#endif	13	#endif
13		14
...	@@ -132,19 +133,16 @@ __sp_mut& __get_sp_mut(const void* p) {	...	@@ -132,19 +133,16 @@ __sp_mut& __get_sp_mut(const void* p) {
132		133
133	#endif // _LIBCPP_HAS_THREADS	134	#endif // _LIBCPP_HAS_THREADS
134		135
135	void* align(size_t alignment, size_t size, void*& ptr, size_t& space) {	136	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 21
136	void* r = nullptr;	137
137	if (size <= space) {	138	_LIBCPP_DIAGNOSTIC_PUSH
138	char* p1 = static_cast<char*>(ptr);	139	_LIBCPP_CLANG_DIAGNOSTIC_IGNORED("-Wmissing-prototypes")
139	char* p2 = reinterpret_cast<char*>(reinterpret_cast<uintptr_t>(p1 + (alignment - 1)) & -alignment);	140	// This function only exists for ABI compatibility and we therefore don't provide a declaration in the headers
140	size_t d = static_cast<size_t>(p2 - p1);	141	_LIBCPP_EXPORTED_FROM_ABI void* align(size_t alignment, size_t size, void*& ptr, size_t& space) {
141	if (d <= space - size) {	142	return __align_inline::align(alignment, size, ptr, space);
142	r = p2;
143	ptr = r;
144	space -= d;
145	}
146	}
147	return r;
148	}	143	}
		144	_LIBCPP_DIAGNOSTIC_POP
		145
		146	#endif
149		147
150	_LIBCPP_END_NAMESPACE_STD	148	_LIBCPP_END_NAMESPACE_STD

lib/libcxx/src/mutex_destructor.cpp+1-1

...	@@ -19,7 +19,7 @@	...	@@ -19,7 +19,7 @@
19	#include <__config>	19	#include <__config>
20	#include <__thread/support.h>	20	#include <__thread/support.h>
21		21
22	#if _LIBCPP_ABI_VERSION == 1 \|\| !_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION	22	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 9 \|\| !_LIBCPP_HAS_TRIVIAL_MUTEX_DESTRUCTION
23	# define NEEDS_MUTEX_DESTRUCTOR	23	# define NEEDS_MUTEX_DESTRUCTOR
24	#endif	24	#endif
25		25

lib/libcxx/src/new.cpp+5-5

...	@@ -6,9 +6,9 @@	...	@@ -6,9 +6,9 @@
6	//	6	//
7	//===----------------------------------------------------------------------===//	7	//===----------------------------------------------------------------------===//
8		8
		9	#include "include/aligned_alloc.h"
9	#include "include/overridable_function.h"	10	#include "include/overridable_function.h"
10	#include <__assert>	11	#include <__assert>
11	#include <__memory/aligned_alloc.h>
12	#include <cstddef>	12	#include <cstddef>
13	#include <cstdlib>	13	#include <cstdlib>
14	#include <new>	14	#include <new>
...	@@ -43,7 +43,7 @@ static void* operator_new_impl(std::size_t size) {	...	@@ -43,7 +43,7 @@ static void* operator_new_impl(std::size_t size) {
43	return p;	43	return p;
44	}	44	}
45		45
46	_LIBCPP_OVERRIDABLE_FUNCTION(void*, operator new, (std::size_t size)) _THROW_BAD_ALLOC {	46	OVERRIDABLE_FUNCTION void* operator new(std::size_t size) _THROW_BAD_ALLOC {
47	void* p = operator_new_impl(size);	47	void* p = operator_new_impl(size);
48	if (p == nullptr)	48	if (p == nullptr)
49	__throw_bad_alloc_shim();	49	__throw_bad_alloc_shim();
...	@@ -74,7 +74,7 @@ _LIBCPP_WEAK void* operator new(size_t size, const std::nothrow_t&) noexcept {	...	@@ -74,7 +74,7 @@ _LIBCPP_WEAK void* operator new(size_t size, const std::nothrow_t&) noexcept {
74	# endif	74	# endif
75	}	75	}
76		76
77	_LIBCPP_OVERRIDABLE_FUNCTION(void*, operator new[], (size_t size)) _THROW_BAD_ALLOC { return ::operator new(size); }	77	OVERRIDABLE_FUNCTION void* operator new[](size_t size) _THROW_BAD_ALLOC { return ::operator new(size); }
78		78
79	_LIBCPP_WEAK void* operator new[](size_t size, const std::nothrow_t&) noexcept {	79	_LIBCPP_WEAK void* operator new[](size_t size, const std::nothrow_t&) noexcept {
80	# if !_LIBCPP_HAS_EXCEPTIONS	80	# if !_LIBCPP_HAS_EXCEPTIONS
...	@@ -134,7 +134,7 @@ static void* operator_new_aligned_impl(std::size_t size, std::align_val_t alignm	...	@@ -134,7 +134,7 @@ static void* operator_new_aligned_impl(std::size_t size, std::align_val_t alignm
134	return p;	134	return p;
135	}	135	}
136		136
137	_LIBCPP_OVERRIDABLE_FUNCTION(void*, operator new, (std::size_t size, std::align_val_t alignment)) _THROW_BAD_ALLOC {	137	OVERRIDABLE_FUNCTION void* operator new(std::size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
138	void* p = operator_new_aligned_impl(size, alignment);	138	void* p = operator_new_aligned_impl(size, alignment);
139	if (p == nullptr)	139	if (p == nullptr)
140	__throw_bad_alloc_shim();	140	__throw_bad_alloc_shim();
...	@@ -165,7 +165,7 @@ _LIBCPP_WEAK void* operator new(size_t size, std::align_val_t alignment, const s	...	@@ -165,7 +165,7 @@ _LIBCPP_WEAK void* operator new(size_t size, std::align_val_t alignment, const s
165	# endif	165	# endif
166	}	166	}
167		167
168	_LIBCPP_OVERRIDABLE_FUNCTION(void*, operator new[], (size_t size, std::align_val_t alignment)) _THROW_BAD_ALLOC {	168	OVERRIDABLE_FUNCTION void* operator new[](size_t size, std::align_val_t alignment) _THROW_BAD_ALLOC {
169	return ::operator new(size, alignment);	169	return ::operator new(size, alignment);
170	}	170	}
171		171

lib/libcxx/src/optional.cpp+4

...	@@ -19,6 +19,8 @@ const char* bad_optional_access::what() const noexcept { return "bad_optional_ac	...	@@ -19,6 +19,8 @@ const char* bad_optional_access::what() const noexcept { return "bad_optional_ac
19		19
20	#include <__config>	20	#include <__config>
21		21
		22	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 7
		23
22	// Preserve std::experimental::bad_optional_access for ABI compatibility	24	// Preserve std::experimental::bad_optional_access for ABI compatibility
23	// Even though it no longer exists in a header file	25	// Even though it no longer exists in a header file
24	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL	26	_LIBCPP_BEGIN_NAMESPACE_EXPERIMENTAL
...	@@ -34,3 +36,5 @@ public:	...	@@ -34,3 +36,5 @@ public:
34	bad_optional_access::~bad_optional_access() noexcept = default;	36	bad_optional_access::~bad_optional_access() noexcept = default;
35		37
36	_LIBCPP_END_NAMESPACE_EXPERIMENTAL	38	_LIBCPP_END_NAMESPACE_EXPERIMENTAL
		39
		40	#endif // _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 7

lib/libcxx/src/print.cpp+9-1

 @@ -22,6 +22,14 @@
 #  include <windows.h>
 #elif __has_include(<unistd.h>)
 #  include <unistd.h>
+#  if defined(_NEWLIB_VERSION)
+#    if defined(_POSIX_C_SOURCE) && __has_include(<stdio.h>)
+#      include <stdio.h>
+#      define HAS_FILENO_AND_ISATTY
+#    endif
+#  else
+#    define HAS_FILENO_AND_ISATTY
+#  endif
 #endif
 _LIBCPP_BEGIN_NAMESPACE_STD
 @@ -56,7 +64,7 @@ __write_to_windows_console([[maybe_unused]] FILE* __stream, [[maybe_unused]] wst
 }
 #  endif // _LIBCPP_HAS_WIDE_CHARACTERS
-#elif __has_include(<unistd.h>) // !_LIBCPP_WIN32API
+#elif defined(HAS_FILENO_AND_ISATTY) // !_LIBCPP_WIN32API
 _LIBCPP_EXPORTED_FROM_ABI bool __is_posix_terminal(FILE* __stream) { return isatty(fileno(__stream)); }
 #endif

lib/libcxx/src/random.cpp-26

...	@@ -31,8 +31,6 @@	...	@@ -31,8 +31,6 @@
31	# include <linux/random.h>	31	# include <linux/random.h>
32	# include <sys/ioctl.h>	32	# include <sys/ioctl.h>
33	# endif	33	# endif
34	#elif defined(_LIBCPP_USING_NACL_RANDOM)
35	# include <nacl/nacl_random.h>
36	#elif defined(_LIBCPP_USING_FUCHSIA_CPRNG)	34	#elif defined(_LIBCPP_USING_FUCHSIA_CPRNG)
37	# include <zircon/syscalls.h>	35	# include <zircon/syscalls.h>
38	#endif	36	#endif
...	@@ -93,30 +91,6 @@ unsigned random_device::operator()() {	...	@@ -93,30 +91,6 @@ unsigned random_device::operator()() {
93	return r;	91	return r;
94	}	92	}
95		93
96	#elif defined(_LIBCPP_USING_NACL_RANDOM)
97
98	random_device::random_device(const string& __token) {
99	if (__token != "/dev/urandom")
100	std::__throw_system_error(ENOENT, ("random device not supported " + __token).c_str());
101	int error = nacl_secure_random_init();
102	if (error)
103	std::__throw_system_error(error, ("random device failed to open " + __token).c_str());
104	}
105
106	random_device::~random_device() {}
107
108	unsigned random_device::operator()() {
109	unsigned r;
110	size_t n = sizeof(r);
111	size_t bytes_written;
112	int error = nacl_secure_random(&r, n, &bytes_written);
113	if (error != 0)
114	std::__throw_system_error(error, "random_device failed getting bytes");
115	else if (bytes_written != n)
116	std::__throw_runtime_error("random_device failed to obtain enough bytes");
117	return r;
118	}
119
120	#elif defined(_LIBCPP_USING_WIN32_RANDOM)	94	#elif defined(_LIBCPP_USING_WIN32_RANDOM)
121		95
122	random_device::random_device(const string& __token) {	96	random_device::random_device(const string& __token) {

lib/libcxx/src/string.cpp+10-25

 @@ -20,7 +20,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
-#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 14
 template <bool>
 struct __basic_string_common;
 @@ -35,45 +35,30 @@ struct __basic_string_common<true> {
 void __basic_string_common<true>::__throw_length_error() const { std::__throw_length_error("basic_string"); }
 void __basic_string_common<true>::__throw_out_of_range() const { std::__throw_out_of_range("basic_string"); }
-#endif // _LIBCPP_ABI_DO_NOT_EXPORT_BASIC_STRING_COMMON
+#endif // _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 14
 // Define legacy ABI functions
 // ---------------------------
-#ifndef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
+#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 21
+// This initializes the string with [__s, __s + __sz), but capacity() == __reserve. Assumes that __reserve >= __sz.
 template <class _CharT, class _Traits, class _Allocator>
 void basic_string<_CharT, _Traits, _Allocator>::__init(const value_type* __s, size_type __sz, size_type __reserve) {
-  if (__libcpp_is_constant_evaluated())
+  pointer __p = __init_internal_buffer(__reserve);
-    __rep_ = __rep();
+  __annotate_delete();
-  if (__reserve > max_size())
+  __set_size(__sz);
-    __throw_length_error();
-  pointer __p;
-  if (__fits_in_sso(__reserve)) {
-    __set_short_size(__sz);
-    __p = __get_short_pointer();
-  } else {
-    auto __allocation = std::__allocate_at_least(__alloc_, __recommend(__reserve) + 1);
-    __p               = __allocation.ptr;
-    __begin_lifetime(__p, __allocation.count);
-    __set_long_pointer(__p);
-    __set_long_cap(__allocation.count);
-    __set_long_size(__sz);
-  }
   traits_type::copy(std::__to_address(__p), __s, __sz);
   traits_type::assign(__p[__sz], value_type());
   __annotate_new(__sz);
 }
-#  define STRING_LEGACY_API(CharT)                                                                                     \
+template _LIBCPP_EXPORTED_FROM_ABI void basic_string<char>::__init(const value_type*, size_type, size_type);
-    template _LIBCPP_EXPORTED_FROM_ABI void basic_string<CharT>::__init(const value_type*, size_type, size_type)
-STRING_LEGACY_API(char);
 #  if _LIBCPP_HAS_WIDE_CHARACTERS
-STRING_LEGACY_API(wchar_t);
+template _LIBCPP_EXPORTED_FROM_ABI void basic_string<wchar_t>::__init(const value_type*, size_type, size_type);
 #  endif
-#endif // _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION
+#endif // _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 21
 #define _LIBCPP_EXTERN_TEMPLATE_DEFINE(...) template _LIBCPP_EXPORTED_FROM_ABI __VA_ARGS__;
 #ifdef _LIBCPP_ABI_STRING_OPTIMIZED_EXTERNAL_INSTANTIATION

lib/libcxx/src/support/runtime/exception_fallback.ipp+2

...	@@ -8,6 +8,8 @@	...	@@ -8,6 +8,8 @@
8	//===----------------------------------------------------------------------===//	8	//===----------------------------------------------------------------------===//
9		9
10	#include <__verbose_abort>	10	#include <__verbose_abort>
		11	#include <exception>
		12	#include "include/atomic_support.h"
11		13
12	namespace std {	14	namespace std {
13		15

lib/libcxx/src/support/runtime/exception_glibcxx.ipp+3

...	@@ -11,6 +11,9 @@	...	@@ -11,6 +11,9 @@
11	# error header can only be used when targeting libstdc++ or libsupc++	11	# error header can only be used when targeting libstdc++ or libsupc++
12	#endif	12	#endif
13		13
		14	#include <exception>
		15	#include <new>
		16
14	namespace std {	17	namespace std {
15		18
16	bad_alloc::bad_alloc() noexcept {}	19	bad_alloc::bad_alloc() noexcept {}

lib/libcxx/src/support/runtime/exception_libcxxabi.ipp+6-2

 @@ -7,6 +7,10 @@
 //
 //===----------------------------------------------------------------------===//
+#include <exception>
+#include <cxxabi.h>
 #ifndef _LIBCPPABI_VERSION
 #  error this header can only be used with libc++abi
 #endif
 @@ -17,9 +21,9 @@ bool uncaught_exception() noexcept { return uncaught_exceptions() > 0; }
 int uncaught_exceptions() noexcept {
 #if _LIBCPPABI_VERSION > 1001
-  return __cxa_uncaught_exceptions();
+  return abi::__cxa_uncaught_exceptions();
 #else
-  return __cxa_uncaught_exception() ? 1 : 0;
+  return abi::__cxa_uncaught_exception() ? 1 : 0;
 #endif
 }

lib/libcxx/src/support/runtime/exception_libcxxrt.ipp+2

...	@@ -11,6 +11,8 @@	...	@@ -11,6 +11,8 @@
11	# error this header may only be used when targeting libcxxrt	11	# error this header may only be used when targeting libcxxrt
12	#endif	12	#endif
13		13
		14	#include <exception>
		15
14	namespace std {	16	namespace std {
15		17
16	bad_exception::~bad_exception() noexcept {}	18	bad_exception::~bad_exception() noexcept {}

lib/libcxx/src/support/runtime/exception_msvc.ipp+2

...	@@ -12,6 +12,8 @@	...	@@ -12,6 +12,8 @@
12	#endif	12	#endif
13		13
14	#include <__verbose_abort>	14	#include <__verbose_abort>
		15	#include <exception>
		16	#include <new>
15		17
16	extern "C" {	18	extern "C" {
17	typedef void(__cdecl* terminate_handler)();	19	typedef void(__cdecl* terminate_handler)();

lib/libcxx/src/support/runtime/exception_pointer_cxxabi.ipp+9-10

 @@ -7,22 +7,21 @@
 //
 //===----------------------------------------------------------------------===//
-#ifndef HAVE_DEPENDENT_EH_ABI
+#include <cxxabi.h>
-#  error this header may only be used with libc++abi or libcxxrt
+#include <exception>
-#endif
 namespace std {
-exception_ptr::~exception_ptr() noexcept { __cxa_decrement_exception_refcount(__ptr_); }
+exception_ptr::~exception_ptr() noexcept { abi::__cxa_decrement_exception_refcount(__ptr_); }
 exception_ptr::exception_ptr(const exception_ptr& other) noexcept : __ptr_(other.__ptr_) {
-  __cxa_increment_exception_refcount(__ptr_);
+  abi::__cxa_increment_exception_refcount(__ptr_);
 }
 exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept {
   if (__ptr_ != other.__ptr_) {
-    __cxa_increment_exception_refcount(other.__ptr_);
+    abi::__cxa_increment_exception_refcount(other.__ptr_);
-    __cxa_decrement_exception_refcount(__ptr_);
+    abi::__cxa_decrement_exception_refcount(__ptr_);
     __ptr_ = other.__ptr_;
   }
   return *this;
 @@ -31,7 +30,7 @@ exception_ptr& exception_ptr::operator=(const exception_ptr& other) noexcept {
 exception_ptr exception_ptr::__from_native_exception_pointer(void* __e) noexcept {
   exception_ptr ptr;
   ptr.__ptr_ = __e;
-  __cxa_increment_exception_refcount(ptr.__ptr_);
+  abi::__cxa_increment_exception_refcount(ptr.__ptr_);
   return ptr;
 }
 @@ -51,12 +50,12 @@ exception_ptr current_exception() noexcept {
   // this whole function would be just:
   //    return exception_ptr(__cxa_current_primary_exception());
   exception_ptr ptr;
-  ptr.__ptr_ = __cxa_current_primary_exception();
+  ptr.__ptr_ = abi::__cxa_current_primary_exception();
   return ptr;
 }
 void rethrow_exception(exception_ptr p) {
-  __cxa_rethrow_primary_exception(p.__ptr_);
+  abi::__cxa_rethrow_primary_exception(p.__ptr_);
   // if p.__ptr_ is NULL, above returns so we terminate
   terminate();
 }

lib/libcxx/src/support/runtime/exception_pointer_glibcxx.ipp+2

...	@@ -16,6 +16,8 @@	...	@@ -16,6 +16,8 @@
16	// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)	16	// stable ABI), and its rethrow_exception(std::__exception_ptr::exception_ptr)
17	// function.	17	// function.
18		18
		19	#include <exception>
		20
19	namespace std {	21	namespace std {
20		22
21	namespace __exception_ptr {	23	namespace __exception_ptr {

lib/libcxx/src/support/runtime/exception_pointer_msvc.ipp+1

...	@@ -7,6 +7,7 @@	...	@@ -7,6 +7,7 @@
7	//	7	//
8	//===----------------------------------------------------------------------===//	8	//===----------------------------------------------------------------------===//
9		9
		10	#include <exception>
10	#include <stdio.h>	11	#include <stdio.h>
11	#include <stdlib.h>	12	#include <stdlib.h>
12		13

lib/libcxx/src/support/runtime/exception_pointer_unimplemented.ipp+1

...	@@ -8,6 +8,7 @@	...	@@ -8,6 +8,7 @@
8	//===----------------------------------------------------------------------===//	8	//===----------------------------------------------------------------------===//
9		9
10	#include <__verbose_abort>	10	#include <__verbose_abort>
		11	#include <exception>
11		12
12	namespace std {	13	namespace std {
13		14

lib/libcxx/src/support/win32/locale_win32.cpp+1-1

...	@@ -144,7 +144,7 @@ int __snprintf(char* ret, size_t n, __locale_t loc, const char* format, ...) {	...	@@ -144,7 +144,7 @@ int __snprintf(char* ret, size_t n, __locale_t loc, const char* format, ...) {
144	// Like sprintf, but when return value >= 0 it returns	144	// Like sprintf, but when return value >= 0 it returns
145	// a pointer to a malloc'd string in *sptr.	145	// a pointer to a malloc'd string in *sptr.
146	// If return >= 0, use free to delete *sptr.	146	// If return >= 0, use free to delete *sptr.
147	int __libcpp_vasprintf(char** sptr, const char* __restrict format, va_list ap) {	147	static int __libcpp_vasprintf(char** sptr, const char* __restrict format, va_list ap) {
148	*sptr = nullptr;	148	*sptr = nullptr;
149	// Query the count required.	149	// Query the count required.
150	va_list ap_copy;	150	va_list ap_copy;

lib/libcxx/src/system_error.cpp+2

...	@@ -95,6 +95,8 @@ std::optional<errc> __win_err_to_errc(int err) {	...	@@ -95,6 +95,8 @@ std::optional<errc> __win_err_to_errc(int err) {
95	return errc::no_lock_available;	95	return errc::no_lock_available;
96	case ERROR_NEGATIVE_SEEK:	96	case ERROR_NEGATIVE_SEEK:
97	return errc::invalid_argument;	97	return errc::invalid_argument;
		98	case ERROR_NETNAME_DELETED:
		99	return errc::no_such_file_or_directory;
98	case ERROR_NOACCESS:	100	case ERROR_NOACCESS:
99	return errc::permission_denied;	101	return errc::permission_denied;
100	case ERROR_NOT_ENOUGH_MEMORY:	102	case ERROR_NOT_ENOUGH_MEMORY:

lib/libcxx/src/thread.cpp+1-3

 @@ -74,9 +74,7 @@ unsigned thread::hardware_concurrency() noexcept {
     return 0;
   return static_cast<unsigned>(result);
 #elif defined(_LIBCPP_WIN32API)
-  SYSTEM_INFO info;
+  return static_cast<unsigned>(GetActiveProcessorCount(ALL_PROCESSOR_GROUPS));
-  GetSystemInfo(&info);
-  return info.dwNumberOfProcessors;
 #else // defined(CTL_HW) && defined(HW_NCPU)
   // TODO: grovel through /proc or check cpuid on x86 and similar
   // instructions on other architectures.

lib/libcxx/src/valarray.cpp+1-2

...	@@ -10,8 +10,7 @@	...	@@ -10,8 +10,7 @@
10		10
11	_LIBCPP_BEGIN_NAMESPACE_STD	11	_LIBCPP_BEGIN_NAMESPACE_STD
12		12
13	// These two symbols are part of the v1 ABI but not part of the >=v2 ABI.	13	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 9
14	#if _LIBCPP_ABI_VERSION == 1
15	template _LIBCPP_EXPORTED_FROM_ABI valarray<size_t>::valarray(size_t);	14	template _LIBCPP_EXPORTED_FROM_ABI valarray<size_t>::valarray(size_t);
16	template _LIBCPP_EXPORTED_FROM_ABI valarray<size_t>::~valarray();	15	template _LIBCPP_EXPORTED_FROM_ABI valarray<size_t>::~valarray();
17	#endif	16	#endif

lib/libcxx/src/vector.cpp+2-2

...	@@ -10,7 +10,7 @@	...	@@ -10,7 +10,7 @@
10		10
11	_LIBCPP_BEGIN_NAMESPACE_STD	11	_LIBCPP_BEGIN_NAMESPACE_STD
12		12
13	#ifndef _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON	13	#if _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 15
14		14
15	template <bool>	15	template <bool>
16	struct __vector_base_common;	16	struct __vector_base_common;
...	@@ -25,6 +25,6 @@ void __vector_base_common<true>::__throw_length_error() const { std::__throw_len	...	@@ -25,6 +25,6 @@ void __vector_base_common<true>::__throw_length_error() const { std::__throw_len
25		25
26	void __vector_base_common<true>::__throw_out_of_range() const { std::__throw_out_of_range("vector"); }	26	void __vector_base_common<true>::__throw_out_of_range() const { std::__throw_out_of_range("vector"); }
27		27
28	#endif // _LIBCPP_ABI_DO_NOT_EXPORT_VECTOR_BASE_COMMON	28	#endif // _LIBCPP_AVAILABILITY_MINIMUM_HEADER_VERSION < 15
29		29
30	_LIBCPP_END_NAMESPACE_STD	30	_LIBCPP_END_NAMESPACE_STD

src/libs/libcxx.zig+14-5

 @@ -538,11 +538,20 @@ pub fn addCxxArgs(
     // Compilation.addCCArgs. This option makes it use serial backend which
     // is simple and works everywhere.
     try cflags.append("-D_LIBCPP_PSTL_BACKEND_SERIAL");
-    try cflags.append(switch (optimize_mode) {
+    switch (optimize_mode) {
-        .Debug => "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG",
+        .Debug => {
-        .ReleaseFast, .ReleaseSmall => "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_NONE",
+            try cflags.append("-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_DEBUG");
-        .ReleaseSafe => "-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST",
+            try cflags.append("-D_LIBCPP_ASSERTION_SEMANTIC_DEFAULT=_LIBCPP_ASSERTION_SEMANTIC_ENFORCE");
-    });
+        },
+        .ReleaseFast, .ReleaseSmall => {
+            try cflags.append("-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_NONE");
+            try cflags.append("-D_LIBCPP_ASSERTION_SEMANTIC_DEFAULT=_LIBCPP_ASSERTION_SEMANTIC_IGNORE");
+        },
+        .ReleaseSafe => {
+            try cflags.append("-D_LIBCPP_HARDENING_MODE=_LIBCPP_HARDENING_MODE_FAST");
+            try cflags.append("-D_LIBCPP_ASSERTION_SEMANTIC_DEFAULT=_LIBCPP_ASSERTION_SEMANTIC_ENFORCE");
+        },
+    }
     if (target.isGnuLibC()) {
         // glibc 2.16 introduced aligned_alloc
         if (target.os.versionRange().gnuLibCVersion().?.order(.{ .major = 2, .minor = 16, .patch = 0 }) == .lt) {

author	Alex Rønne Petersen <alex@alexrp.com> 2026-01-17 05:40:55+01:00
committer	Alex Rønne Petersen <alex@alexrp.com> 2026-04-25 21:49:39+02:00
log	dfabf1586fa2fcd9350e204fa138f44f952acbfd
tree	0772d518264f9deab3eb70b04167bb5df72ac88f
parent	80212b03ff792ddfff82092b35aa7ed0fdf937a8
signature	Signed by SSH key SHA256:7B/LJ7bpR1eX8aCXSr4mtd5M45VMPKcx9zY8e95b5QM

...	@@ -60,7 +60,7 @@ __mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Pred& __pred, _Pro	...	@@ -60,7 +60,7 @@ __mismatch(_Iter1 __first1, _Sent1 __last1, _Iter2 __first2, _Pred& __pred, _Pro
60	template <class _Iter>	60	template <class _Iter>
61	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter, _Iter>	61	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Iter, _Iter>
62	__mismatch_vectorized(_Iter __first1, _Iter __last1, _Iter __first2) {	62	__mismatch_vectorized(_Iter __first1, _Iter __last1, _Iter __first2) {
63	using __value_type = __iter_value_type<_Iter>;	63	using __value_type = __iterator_value_type<_Iter>;
64	constexpr size_t __unroll_count = 4;	64	constexpr size_t __unroll_count = 4;
65	constexpr size_t __vec_size = __native_vector_size<__value_type>;	65	constexpr size_t __vec_size = __native_vector_size<__value_type>;
66	using __vec = __simd_vector<__value_type, __vec_size>;	66	using __vec = __simd_vector<__value_type, __vec_size>;
...	@@ -136,7 +136,7 @@ template <class _Tp,	...	@@ -136,7 +136,7 @@ template <class _Tp,
136	class _Proj2,	136	class _Proj2,
137	__enable_if_t<!is_integral<_Tp>::value && __desugars_to_v<__equal_tag, _Pred, _Tp, _Tp> &&	137	__enable_if_t<!is_integral<_Tp>::value && __desugars_to_v<__equal_tag, _Pred, _Tp, _Tp> &&
138	__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&	138	__is_identity<_Proj1>::value && __is_identity<_Proj2>::value &&
139	__can_map_to_integer_v<_Tp> && __libcpp_is_trivially_equality_comparable<_Tp, _Tp>::value,	139	__can_map_to_integer_v<_Tp> && __is_trivially_equality_comparable_v<_Tp, _Tp>,
140	int> = 0>	140	int> = 0>
141	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Tp, _Tp>	141	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR_SINCE_CXX20 pair<_Tp, _Tp>
142	__mismatch(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {	142	__mismatch(_Tp* __first1, _Tp* __last1, _Tp* __first2, _Pred& __pred, _Proj1& __proj1, _Proj2& __proj2) {

...	@@ -115,7 +115,7 @@ template <class _ExecutionPolicy,	...	@@ -115,7 +115,7 @@ template <class _ExecutionPolicy,
115	class _Predicate,	115	class _Predicate,
116	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	116	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
117	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	117	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
118	_LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator>	118	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __iterator_difference_type<_ForwardIterator>
119	count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {	119	count_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
120	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(	120	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
121	_ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");	121	_ForwardIterator, "count_if(first, last, pred) requires [first, last) to be ForwardIterators");
...	@@ -129,7 +129,7 @@ template <class _ExecutionPolicy,	...	@@ -129,7 +129,7 @@ template <class _ExecutionPolicy,
129	class _Tp,	129	class _Tp,
130	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	130	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
131	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	131	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
132	_LIBCPP_HIDE_FROM_ABI __iter_diff_t<_ForwardIterator>	132	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI __iterator_difference_type<_ForwardIterator>
133	count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {	133	count(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
134	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(	134	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(
135	_ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");	135	_ForwardIterator, "count(first, last, val) requires [first, last) to be ForwardIterators");
...	@@ -144,7 +144,7 @@ template <class _ExecutionPolicy,	...	@@ -144,7 +144,7 @@ template <class _ExecutionPolicy,
144	class _Pred,	144	class _Pred,
145	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	145	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
146	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	146	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
147	_LIBCPP_HIDE_FROM_ABI bool	147	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
148	equal(_ExecutionPolicy&& __policy,	148	equal(_ExecutionPolicy&& __policy,
149	_ForwardIterator1 __first1,	149	_ForwardIterator1 __first1,
150	_ForwardIterator1 __last1,	150	_ForwardIterator1 __last1,
...	@@ -166,7 +166,7 @@ template <class _ExecutionPolicy,	...	@@ -166,7 +166,7 @@ template <class _ExecutionPolicy,
166	class _ForwardIterator2,	166	class _ForwardIterator2,
167	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	167	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
168	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	168	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
169	_LIBCPP_HIDE_FROM_ABI bool	169	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
170	equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {	170	equal(_ExecutionPolicy&& __policy, _ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardIterator2 __first2) {
171	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");	171	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator1, "equal requires ForwardIterators");
172	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");	172	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator2, "equal requires ForwardIterators");
...	@@ -185,7 +185,7 @@ template <class _ExecutionPolicy,	...	@@ -185,7 +185,7 @@ template <class _ExecutionPolicy,
185	class _Pred,	185	class _Pred,
186	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	186	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
187	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	187	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
188	_LIBCPP_HIDE_FROM_ABI bool	188	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
189	equal(_ExecutionPolicy&& __policy,	189	equal(_ExecutionPolicy&& __policy,
190	_ForwardIterator1 __first1,	190	_ForwardIterator1 __first1,
191	_ForwardIterator1 __last1,	191	_ForwardIterator1 __last1,
...	@@ -209,7 +209,7 @@ template <class _ExecutionPolicy,	...	@@ -209,7 +209,7 @@ template <class _ExecutionPolicy,
209	class _ForwardIterator2,	209	class _ForwardIterator2,
210	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	210	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
211	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	211	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
212	_LIBCPP_HIDE_FROM_ABI bool	212	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool
213	equal(_ExecutionPolicy&& __policy,	213	equal(_ExecutionPolicy&& __policy,
214	_ForwardIterator1 __first1,	214	_ForwardIterator1 __first1,
215	_ForwardIterator1 __last1,	215	_ForwardIterator1 __last1,
...	@@ -259,7 +259,7 @@ template <class _ExecutionPolicy,	...	@@ -259,7 +259,7 @@ template <class _ExecutionPolicy,
259	class _Predicate,	259	class _Predicate,
260	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	260	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
261	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	261	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
262	_LIBCPP_HIDE_FROM_ABI _ForwardIterator	262	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
263	find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {	263	find_if(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
264	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");	264	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if requires ForwardIterators");
265	using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;	265	using _Implementation = __pstl::__dispatch<__pstl::__find_if, __pstl::__current_configuration, _RawPolicy>;
...	@@ -272,7 +272,7 @@ template <class _ExecutionPolicy,	...	@@ -272,7 +272,7 @@ template <class _ExecutionPolicy,
272	class _Predicate,	272	class _Predicate,
273	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	273	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
274	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	274	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
275	_LIBCPP_HIDE_FROM_ABI _ForwardIterator	275	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
276	find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {	276	find_if_not(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate __pred) {
277	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");	277	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find_if_not requires ForwardIterators");
278	using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;	278	using _Implementation = __pstl::__dispatch<__pstl::__find_if_not, __pstl::__current_configuration, _RawPolicy>;
...	@@ -285,7 +285,7 @@ template <class _ExecutionPolicy,	...	@@ -285,7 +285,7 @@ template <class _ExecutionPolicy,
285	class _Tp,	285	class _Tp,
286	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,	286	class _RawPolicy = __remove_cvref_t<_ExecutionPolicy>,
287	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>	287	enable_if_t<is_execution_policy_v<_RawPolicy>, int> = 0>
288	_LIBCPP_HIDE_FROM_ABI _ForwardIterator	288	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _ForwardIterator
289	find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {	289	find(_ExecutionPolicy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) {
290	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");	290	_LIBCPP_REQUIRE_CPP17_FORWARD_ITERATOR(_ForwardIterator, "find requires ForwardIterators");
291	using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;	291	using _Implementation = __pstl::__dispatch<__pstl::__find, __pstl::__current_configuration, _RawPolicy>;

...	@@ -12,6 +12,7 @@	...	@@ -12,6 +12,7 @@
12	#include <__compare/common_comparison_category.h>	12	#include <__compare/common_comparison_category.h>
13	#include <__compare/ordering.h>	13	#include <__compare/ordering.h>
14	#include <__concepts/common_reference_with.h>	14	#include <__concepts/common_reference_with.h>
		15	#include <__concepts/comparison_common_type.h>
15	#include <__concepts/equality_comparable.h>	16	#include <__concepts/equality_comparable.h>
16	#include <__concepts/same_as.h>	17	#include <__concepts/same_as.h>
17	#include <__concepts/totally_ordered.h>	18	#include <__concepts/totally_ordered.h>
...	@@ -39,8 +40,7 @@ concept three_way_comparable =	...	@@ -39,8 +40,7 @@ concept three_way_comparable =
39		40
40	template <class _Tp, class _Up, class _Cat = partial_ordering>	41	template <class _Tp, class _Up, class _Cat = partial_ordering>
41	concept three_way_comparable_with =	42	concept three_way_comparable_with =
42	three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> &&	43	three_way_comparable<_Tp, _Cat> && three_way_comparable<_Up, _Cat> && __comparison_common_type_with<_Tp, _Up> &&
43	common_reference_with<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>> &&
44	three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&	44	three_way_comparable<common_reference_t<__make_const_lvalue_ref<_Tp>, __make_const_lvalue_ref<_Up>>, _Cat> &&
45	__weakly_equality_comparable_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&	45	__weakly_equality_comparable_with<_Tp, _Up> && __partially_ordered_with<_Tp, _Up> &&
46	requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {	46	requires(__make_const_lvalue_ref<_Tp> __t, __make_const_lvalue_ref<_Up> __u) {

...	@@ -20,8 +20,6 @@	...	@@ -20,8 +20,6 @@
20		20
21	_LIBCPP_BEGIN_NAMESPACE_STD	21	_LIBCPP_BEGIN_NAMESPACE_STD
22		22
23	# if __has_builtin(__builtin_coro_noop) \|\| defined(_LIBCPP_COMPILER_GCC)
24
25	// [coroutine.noop]	23	// [coroutine.noop]
26	// [coroutine.promise.noop]	24	// [coroutine.promise.noop]
27	struct noop_coroutine_promise {};	25	struct noop_coroutine_promise {};
...	@@ -37,7 +35,7 @@ public:	...	@@ -37,7 +35,7 @@ public:
37		35
38	// [coroutine.handle.noop.observers], observers	36	// [coroutine.handle.noop.observers], observers
39	_LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return true; }	37	_LIBCPP_HIDE_FROM_ABI constexpr explicit operator bool() const noexcept { return true; }
40	_LIBCPP_HIDE_FROM_ABI constexpr bool done() const noexcept { return false; }	38	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool done() const noexcept { return false; }
41		39
42	// [coroutine.handle.noop.resumption], resumption	40	// [coroutine.handle.noop.resumption], resumption
43	_LIBCPP_HIDE_FROM_ABI constexpr void operator()() const noexcept {}	41	_LIBCPP_HIDE_FROM_ABI constexpr void operator()() const noexcept {}
...	@@ -45,23 +43,23 @@ public:	...	@@ -45,23 +43,23 @@ public:
45	_LIBCPP_HIDE_FROM_ABI constexpr void destroy() const noexcept {}	43	_LIBCPP_HIDE_FROM_ABI constexpr void destroy() const noexcept {}
46		44
47	// [coroutine.handle.noop.promise], promise access	45	// [coroutine.handle.noop.promise], promise access
48	_LIBCPP_HIDE_FROM_ABI noop_coroutine_promise& promise() const noexcept {	46	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI noop_coroutine_promise& promise() const noexcept {
49	return static_cast<noop_coroutine_promise>(	47	return static_cast<noop_coroutine_promise>(
50	__builtin_coro_promise(this->__handle_, alignof(noop_coroutine_promise), false));	48	__builtin_coro_promise(this->__handle_, alignof(noop_coroutine_promise), false));
51	}	49	}
52		50
53	// [coroutine.handle.noop.address], address	51	// [coroutine.handle.noop.address], address
54	_LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }	52	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr void* address() const noexcept { return __handle_; }
55		53
56	private:	54	private:
57	_LIBCPP_HIDE_FROM_ABI friend coroutine_handle<noop_coroutine_promise> noop_coroutine() noexcept;	55	_LIBCPP_HIDE_FROM_ABI friend coroutine_handle<noop_coroutine_promise> noop_coroutine() noexcept;
58		56
59	# if __has_builtin(__builtin_coro_noop)	57	# if __has_builtin(__builtin_coro_noop)
60	_LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept { this->__handle_ = __builtin_coro_noop(); }	58	_LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept { this->__handle_ = __builtin_coro_noop(); }
61		59
62	void* __handle_ = nullptr;	60	void* __handle_ = nullptr;
63		61
64	# elif defined(_LIBCPP_COMPILER_GCC)	62	# elif defined(_LIBCPP_COMPILER_GCC)
65	// GCC doesn't implement __builtin_coro_noop().	63	// GCC doesn't implement __builtin_coro_noop().
66	// Construct the coroutine frame manually instead.	64	// Construct the coroutine frame manually instead.
67	struct __noop_coroutine_frame_ty_ {	65	struct __noop_coroutine_frame_ty_ {
...	@@ -78,19 +76,19 @@ private:	...	@@ -78,19 +76,19 @@ private:
78		76
79	_LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept = default;	77	_LIBCPP_HIDE_FROM_ABI coroutine_handle() noexcept = default;
80		78
81	# endif // __has_builtin(__builtin_coro_noop)	79	# endif // __has_builtin(__builtin_coro_noop)
82	};	80	};
83		81
84	using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;	82	using noop_coroutine_handle = coroutine_handle<noop_coroutine_promise>;
85		83
86	# if defined(_LIBCPP_COMPILER_GCC)	84	# if defined(_LIBCPP_COMPILER_GCC)
87	inline noop_coroutine_handle::__noop_coroutine_frame_ty_ noop_coroutine_handle::__noop_coroutine_frame_{};	85	inline noop_coroutine_handle::__noop_coroutine_frame_ty_ noop_coroutine_handle::__noop_coroutine_frame_{};
88	# endif	86	# endif
89		87
90	// [coroutine.noop.coroutine]	88	// [coroutine.noop.coroutine]
91	inline _LIBCPP_HIDE_FROM_ABI noop_coroutine_handle noop_coroutine() noexcept { return noop_coroutine_handle(); }	89	[[nodiscard]] inline _LIBCPP_HIDE_FROM_ABI noop_coroutine_handle noop_coroutine() noexcept {
92		90	return noop_coroutine_handle();
93	# endif // __has_builtin(__builtin_coro_noop) \|\| defined(_LIBCPP_COMPILER_GCC)	91	}
94		92
95	_LIBCPP_END_NAMESPACE_STD	93	_LIBCPP_END_NAMESPACE_STD
96		94

...	@@ -20,22 +20,22 @@ _LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD	...	@@ -20,22 +20,22 @@ _LIBCPP_BEGIN_UNVERSIONED_NAMESPACE_STD
20	defined(_LIBCPP_BUILDING_LIBRARY)	20	defined(_LIBCPP_BUILDING_LIBRARY)
21	using unexpected_handler = void (*)();	21	using unexpected_handler = void (*)();
22	_LIBCPP_EXPORTED_FROM_ABI unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;	22	_LIBCPP_EXPORTED_FROM_ABI unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
23	_LIBCPP_EXPORTED_FROM_ABI unexpected_handler get_unexpected() _NOEXCEPT;	23	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI unexpected_handler get_unexpected() _NOEXCEPT;
24	[[__noreturn__]] _LIBCPP_EXPORTED_FROM_ABI void unexpected();	24	[[__noreturn__]] _LIBCPP_EXPORTED_FROM_ABI void unexpected();
25	#endif	25	#endif
26		26
27	using terminate_handler = void (*)();	27	using terminate_handler = void (*)();
28	_LIBCPP_EXPORTED_FROM_ABI terminate_handler set_terminate(terminate_handler) _NOEXCEPT;	28	_LIBCPP_EXPORTED_FROM_ABI terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
29	_LIBCPP_EXPORTED_FROM_ABI terminate_handler get_terminate() _NOEXCEPT;	29	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI terminate_handler get_terminate() _NOEXCEPT;
30		30
31	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_UNCAUGHT_EXCEPTION)	31	#if _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_UNCAUGHT_EXCEPTION)
32	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX17 bool uncaught_exception() _NOEXCEPT;	32	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI _LIBCPP_DEPRECATED_IN_CXX17 bool uncaught_exception() _NOEXCEPT;
33	#endif // _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_UNCAUGHT_EXCEPTION)	33	#endif // _LIBCPP_STD_VER <= 17 \|\| defined(_LIBCPP_ENABLE_CXX20_REMOVED_UNCAUGHT_EXCEPTION)
34	_LIBCPP_EXPORTED_FROM_ABI int uncaught_exceptions() _NOEXCEPT;	34	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI int uncaught_exceptions() _NOEXCEPT;
35		35
36	class _LIBCPP_EXPORTED_FROM_ABI exception_ptr;	36	class _LIBCPP_EXPORTED_FROM_ABI exception_ptr;
37		37
38	_LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;	38	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI exception_ptr current_exception() _NOEXCEPT;
39	[[__noreturn__]] _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);	39	[[__noreturn__]] _LIBCPP_EXPORTED_FROM_ABI void rethrow_exception(exception_ptr);
40	_LIBCPP_END_UNVERSIONED_NAMESPACE_STD	40	_LIBCPP_END_UNVERSIONED_NAMESPACE_STD
41		41

...	@@ -40,8 +40,6 @@ _LIBCPP_PUSH_MACROS	...	@@ -40,8 +40,6 @@ _LIBCPP_PUSH_MACROS
40		40
41	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM	41	_LIBCPP_BEGIN_NAMESPACE_FILESYSTEM
42		42
43	_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_PUSH
44
45	class directory_entry {	43	class directory_entry {
46	typedef filesystem::path _Path;	44	typedef filesystem::path _Path;
47		45
...	@@ -89,80 +87,88 @@ public:	...	@@ -89,80 +87,88 @@ public:
89		87
90	_LIBCPP_HIDE_FROM_ABI void refresh(error_code& __ec) noexcept { __refresh(&__ec); }	88	_LIBCPP_HIDE_FROM_ABI void refresh(error_code& __ec) noexcept { __refresh(&__ec); }
91		89
92	_LIBCPP_HIDE_FROM_ABI _Path const& path() const noexcept { return __p_; }	90	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI _Path const& path() const noexcept { return __p_; }
93		91
94	_LIBCPP_HIDE_FROM_ABI operator const _Path&() const noexcept { return __p_; }	92	_LIBCPP_HIDE_FROM_ABI operator const _Path&() const noexcept { return __p_; }
95		93
96	_LIBCPP_HIDE_FROM_ABI bool exists() const { return filesystem::exists(file_status{__get_ft()}); }	94	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool exists() const { return filesystem::exists(file_status{__get_ft()}); }
97		95
98	_LIBCPP_HIDE_FROM_ABI bool exists(error_code& __ec) const noexcept {	96	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool exists(error_code& __ec) const noexcept {
99	return filesystem::exists(file_status{__get_ft(&__ec)});	97	return filesystem::exists(file_status{__get_ft(&__ec)});
100	}	98	}
101		99
102	_LIBCPP_HIDE_FROM_ABI bool is_block_file() const { return __get_ft() == file_type::block; }	100	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_block_file() const { return __get_ft() == file_type::block; }
103		101
104	_LIBCPP_HIDE_FROM_ABI bool is_block_file(error_code& __ec) const noexcept {	102	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_block_file(error_code& __ec) const noexcept {
105	return __get_ft(&__ec) == file_type::block;	103	return __get_ft(&__ec) == file_type::block;
106	}	104	}
107		105
108	_LIBCPP_HIDE_FROM_ABI bool is_character_file() const { return __get_ft() == file_type::character; }	106	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_character_file() const { return __get_ft() == file_type::character; }
109		107
110	_LIBCPP_HIDE_FROM_ABI bool is_character_file(error_code& __ec) const noexcept {	108	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_character_file(error_code& __ec) const noexcept {
111	return __get_ft(&__ec) == file_type::character;	109	return __get_ft(&__ec) == file_type::character;
112	}	110	}
113		111
114	_LIBCPP_HIDE_FROM_ABI bool is_directory() const { return __get_ft() == file_type::directory; }	112	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_directory() const { return __get_ft() == file_type::directory; }
115		113
116	_LIBCPP_HIDE_FROM_ABI bool is_directory(error_code& __ec) const noexcept {	114	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_directory(error_code& __ec) const noexcept {
117	return __get_ft(&__ec) == file_type::directory;	115	return __get_ft(&__ec) == file_type::directory;
118	}	116	}
119		117
120	_LIBCPP_HIDE_FROM_ABI bool is_fifo() const { return __get_ft() == file_type::fifo; }	118	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_fifo() const { return __get_ft() == file_type::fifo; }
121		119
122	_LIBCPP_HIDE_FROM_ABI bool is_fifo(error_code& __ec) const noexcept { return __get_ft(&__ec) == file_type::fifo; }	120	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_fifo(error_code& __ec) const noexcept {
		121	return __get_ft(&__ec) == file_type::fifo;
		122	}
123		123
124	_LIBCPP_HIDE_FROM_ABI bool is_other() const { return filesystem::is_other(file_status{__get_ft()}); }	124	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_other() const { return filesystem::is_other(file_status{__get_ft()}); }
125		125
126	_LIBCPP_HIDE_FROM_ABI bool is_other(error_code& __ec) const noexcept {	126	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_other(error_code& __ec) const noexcept {
127	return filesystem::is_other(file_status{__get_ft(&__ec)});	127	return filesystem::is_other(file_status{__get_ft(&__ec)});
128	}	128	}
129		129
130	_LIBCPP_HIDE_FROM_ABI bool is_regular_file() const { return __get_ft() == file_type::regular; }	130	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_regular_file() const { return __get_ft() == file_type::regular; }
131		131
132	_LIBCPP_HIDE_FROM_ABI bool is_regular_file(error_code& __ec) const noexcept {	132	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_regular_file(error_code& __ec) const noexcept {
133	return __get_ft(&__ec) == file_type::regular;	133	return __get_ft(&__ec) == file_type::regular;
134	}	134	}
135		135
136	_LIBCPP_HIDE_FROM_ABI bool is_socket() const { return __get_ft() == file_type::socket; }	136	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_socket() const { return __get_ft() == file_type::socket; }
137		137
138	_LIBCPP_HIDE_FROM_ABI bool is_socket(error_code& __ec) const noexcept { return __get_ft(&__ec) == file_type::socket; }	138	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_socket(error_code& __ec) const noexcept {
		139	return __get_ft(&__ec) == file_type::socket;
		140	}
139		141
140	_LIBCPP_HIDE_FROM_ABI bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }	142	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_symlink() const { return __get_sym_ft() == file_type::symlink; }
141		143
142	_LIBCPP_HIDE_FROM_ABI bool is_symlink(error_code& __ec) const noexcept {	144	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI bool is_symlink(error_code& __ec) const noexcept {
143	return __get_sym_ft(&__ec) == file_type::symlink;	145	return __get_sym_ft(&__ec) == file_type::symlink;
144	}	146	}
145	_LIBCPP_HIDE_FROM_ABI uintmax_t file_size() const { return __get_size(); }	147	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI uintmax_t file_size() const { return __get_size(); }
146		148
147	_LIBCPP_HIDE_FROM_ABI uintmax_t file_size(error_code& __ec) const noexcept { return __get_size(&__ec); }	149	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI uintmax_t file_size(error_code& __ec) const noexcept { return __get_size(&__ec); }
148		150
149	_LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count() const { return __get_nlink(); }	151	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count() const { return __get_nlink(); }
150		152
151	_LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(error_code& __ec) const noexcept { return __get_nlink(&__ec); }	153	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI uintmax_t hard_link_count(error_code& __ec) const noexcept {
		154	return __get_nlink(&__ec);
		155	}
152		156
153	_LIBCPP_HIDE_FROM_ABI file_time_type last_write_time() const { return __get_write_time(); }	157	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time() const { return __get_write_time(); }
154		158
155	_LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(error_code& __ec) const noexcept {	159	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_time_type last_write_time(error_code& __ec) const noexcept {
156	return __get_write_time(&__ec);	160	return __get_write_time(&__ec);
157	}	161	}
158		162
159	_LIBCPP_HIDE_FROM_ABI file_status status() const { return __get_status(); }	163	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_status status() const { return __get_status(); }
160		164
161	_LIBCPP_HIDE_FROM_ABI file_status status(error_code& __ec) const noexcept { return __get_status(&__ec); }	165	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_status status(error_code& __ec) const noexcept {
		166	return __get_status(&__ec);
		167	}
162		168
163	_LIBCPP_HIDE_FROM_ABI file_status symlink_status() const { return __get_symlink_status(); }	169	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_status symlink_status() const { return __get_symlink_status(); }
164		170
165	_LIBCPP_HIDE_FROM_ABI file_status symlink_status(error_code& __ec) const noexcept {	171	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI file_status symlink_status(error_code& __ec) const noexcept {
166	return __get_symlink_status(&__ec);	172	return __get_symlink_status(&__ec);
167	}	173	}
168		174
...	@@ -459,8 +465,6 @@ private:	...	@@ -459,8 +465,6 @@ private:
459	directory_entry __elem_;	465	directory_entry __elem_;
460	};	466	};
461		467
462	_LIBCPP_AVAILABILITY_FILESYSTEM_LIBRARY_POP
463
464	_LIBCPP_END_NAMESPACE_FILESYSTEM	468	_LIBCPP_END_NAMESPACE_FILESYSTEM
465		469
466	#endif // _LIBCPP_STD_VER >= 17 && _LIBCPP_HAS_FILESYSTEM	470	#endif // _LIBCPP_STD_VER >= 17 && _LIBCPP_HAS_FILESYSTEM

...	@@ -102,7 +102,7 @@ struct __find<__default_backend_tag, _ExecutionPolicy> {	...	@@ -102,7 +102,7 @@ struct __find<__default_backend_tag, _ExecutionPolicy> {
102	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept {	102	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) const noexcept {
103	using _FindIf = __dispatch<__find_if, __current_configuration, _ExecutionPolicy>;	103	using _FindIf = __dispatch<__find_if, __current_configuration, _ExecutionPolicy>;
104	return _FindIf()(	104	return _FindIf()(
105	__policy, std::move(__first), std::move(__last), [&](__iter_reference<_ForwardIterator> __element) {	105	__policy, std::move(__first), std::move(__last), [&](__iterator_reference<_ForwardIterator> __element) {
106	return __element == __value;	106	return __element == __value;
107	});	107	});
108	}	108	}
...	@@ -137,7 +137,7 @@ struct __all_of<__default_backend_tag, _ExecutionPolicy> {	...	@@ -137,7 +137,7 @@ struct __all_of<__default_backend_tag, _ExecutionPolicy> {
137	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>	137	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<bool>
138	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {	138	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred) const noexcept {
139	using _AnyOf = __dispatch<__any_of, __current_configuration, _ExecutionPolicy>;	139	using _AnyOf = __dispatch<__any_of, __current_configuration, _ExecutionPolicy>;
140	auto __res = _AnyOf()(__policy, __first, __last, [&](__iter_reference<_ForwardIterator> __value) {	140	auto __res = _AnyOf()(__policy, __first, __last, [&](__iterator_reference<_ForwardIterator> __value) {
141	return !__pred(__value);	141	return !__pred(__value);
142	});	142	});
143	if (!__res)	143	if (!__res)
...	@@ -204,7 +204,7 @@ struct __fill<__default_backend_tag, _ExecutionPolicy> {	...	@@ -204,7 +204,7 @@ struct __fill<__default_backend_tag, _ExecutionPolicy> {
204	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>	204	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
205	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept {	205	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept {
206	using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;	206	using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
207	using _Ref = __iter_reference<_ForwardIterator>;	207	using _Ref = __iterator_reference<_ForwardIterator>;
208	return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) { __element = __value; });	208	return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) { __element = __value; });
209	}	209	}
210	};	210	};
...	@@ -233,7 +233,7 @@ struct __replace<__default_backend_tag, _ExecutionPolicy> {	...	@@ -233,7 +233,7 @@ struct __replace<__default_backend_tag, _ExecutionPolicy> {
233	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __old, _Tp const& __new)	233	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __old, _Tp const& __new)
234	const noexcept {	234	const noexcept {
235	using _ReplaceIf = __dispatch<__replace_if, __current_configuration, _ExecutionPolicy>;	235	using _ReplaceIf = __dispatch<__replace_if, __current_configuration, _ExecutionPolicy>;
236	using _Ref = __iter_reference<_ForwardIterator>;	236	using _Ref = __iterator_reference<_ForwardIterator>;
237	return _ReplaceIf()(	237	return _ReplaceIf()(
238	__policy, std::move(__first), std::move(__last), [&](_Ref __element) { return __element == __old; }, __new);	238	__policy, std::move(__first), std::move(__last), [&](_Ref __element) { return __element == __old; }, __new);
239	}	239	}
...	@@ -246,7 +246,7 @@ struct __replace_if<__default_backend_tag, _ExecutionPolicy> {	...	@@ -246,7 +246,7 @@ struct __replace_if<__default_backend_tag, _ExecutionPolicy> {
246	_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred, _Tp const& __new_value)	246	_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Pred&& __pred, _Tp const& __new_value)
247	const noexcept {	247	const noexcept {
248	using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;	248	using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
249	using _Ref = __iter_reference<_ForwardIterator>;	249	using _Ref = __iterator_reference<_ForwardIterator>;
250	return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) {	250	return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) {
251	if (__pred(__element))	251	if (__pred(__element))
252	__element = __new_value;	252	__element = __new_value;
...	@@ -260,7 +260,7 @@ struct __generate<__default_backend_tag, _ExecutionPolicy> {	...	@@ -260,7 +260,7 @@ struct __generate<__default_backend_tag, _ExecutionPolicy> {
260	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>	260	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
261	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator&& __gen) const noexcept {	261	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Generator&& __gen) const noexcept {
262	using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;	262	using _ForEach = __dispatch<__for_each, __current_configuration, _ExecutionPolicy>;
263	using _Ref = __iter_reference<_ForwardIterator>;	263	using _Ref = __iterator_reference<_ForwardIterator>;
264	return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) { __element = __gen(); });	264	return _ForEach()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) { __element = __gen(); });
265	}	265	}
266	};	266	};
...	@@ -271,7 +271,7 @@ struct __generate_n<__default_backend_tag, _ExecutionPolicy> {	...	@@ -271,7 +271,7 @@ struct __generate_n<__default_backend_tag, _ExecutionPolicy> {
271	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>	271	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__empty>
272	operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, _Generator&& __gen) const noexcept {	272	operator()(_Policy&& __policy, _ForwardIterator __first, _Size __n, _Generator&& __gen) const noexcept {
273	using _ForEachN = __dispatch<__for_each_n, __current_configuration, _ExecutionPolicy>;	273	using _ForEachN = __dispatch<__for_each_n, __current_configuration, _ExecutionPolicy>;
274	using _Ref = __iter_reference<_ForwardIterator>;	274	using _Ref = __iterator_reference<_ForwardIterator>;
275	return _ForEachN()(__policy, std::move(__first), __n, [&](_Ref __element) { __element = __gen(); });	275	return _ForEachN()(__policy, std::move(__first), __n, [&](_Ref __element) { __element = __gen(); });
276	}	276	}
277	};	277	};
...	@@ -295,11 +295,11 @@ struct __sort<__default_backend_tag, _ExecutionPolicy> {	...	@@ -295,11 +295,11 @@ struct __sort<__default_backend_tag, _ExecutionPolicy> {
295	template <class _ExecutionPolicy>	295	template <class _ExecutionPolicy>
296	struct __count_if<__default_backend_tag, _ExecutionPolicy> {	296	struct __count_if<__default_backend_tag, _ExecutionPolicy> {
297	template <class _Policy, class _ForwardIterator, class _Predicate>	297	template <class _Policy, class _ForwardIterator, class _Predicate>
298	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__iter_diff_t<_ForwardIterator>> operator()(	298	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__iterator_difference_type<_ForwardIterator>> operator()(
299	_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred) const noexcept {	299	_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Predicate&& __pred) const noexcept {
300	using _TransformReduce = __dispatch<__transform_reduce, __current_configuration, _ExecutionPolicy>;	300	using _TransformReduce = __dispatch<__transform_reduce, __current_configuration, _ExecutionPolicy>;
301	using _DiffT = __iter_diff_t<_ForwardIterator>;	301	using _DiffT = __iterator_difference_type<_ForwardIterator>;
302	using _Ref = __iter_reference<_ForwardIterator>;	302	using _Ref = __iterator_reference<_ForwardIterator>;
303	return _TransformReduce()(	303	return _TransformReduce()(
304	__policy, std::move(__first), std::move(__last), _DiffT{}, std::plus{}, [&](_Ref __element) -> _DiffT {	304	__policy, std::move(__first), std::move(__last), _DiffT{}, std::plus{}, [&](_Ref __element) -> _DiffT {
305	return __pred(__element) ? _DiffT(1) : _DiffT(0);	305	return __pred(__element) ? _DiffT(1) : _DiffT(0);
...	@@ -310,10 +310,10 @@ struct __count_if<__default_backend_tag, _ExecutionPolicy> {	...	@@ -310,10 +310,10 @@ struct __count_if<__default_backend_tag, _ExecutionPolicy> {
310	template <class _ExecutionPolicy>	310	template <class _ExecutionPolicy>
311	struct __count<__default_backend_tag, _ExecutionPolicy> {	311	struct __count<__default_backend_tag, _ExecutionPolicy> {
312	template <class _Policy, class _ForwardIterator, class _Tp>	312	template <class _Policy, class _ForwardIterator, class _Tp>
313	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__iter_diff_t<_ForwardIterator>>	313	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI optional<__iterator_difference_type<_ForwardIterator>>
314	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept {	314	operator()(_Policy&& __policy, _ForwardIterator __first, _ForwardIterator __last, _Tp const& __value) const noexcept {
315	using _CountIf = __dispatch<__count_if, __current_configuration, _ExecutionPolicy>;	315	using _CountIf = __dispatch<__count_if, __current_configuration, _ExecutionPolicy>;
316	using _Ref = __iter_reference<_ForwardIterator>;	316	using _Ref = __iterator_reference<_ForwardIterator>;
317	return _CountIf()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) -> bool {	317	return _CountIf()(__policy, std::move(__first), std::move(__last), [&](_Ref __element) -> bool {
318	return __element == __value;	318	return __element == __value;
319	});	319	});
...	@@ -402,7 +402,7 @@ struct __replace_copy_if<__default_backend_tag, _ExecutionPolicy> {	...	@@ -402,7 +402,7 @@ struct __replace_copy_if<__default_backend_tag, _ExecutionPolicy> {
402	_Pred&& __pred,	402	_Pred&& __pred,
403	_Tp const& __new_value) const noexcept {	403	_Tp const& __new_value) const noexcept {
404	using _Transform = __dispatch<__transform, __current_configuration, _ExecutionPolicy>;	404	using _Transform = __dispatch<__transform, __current_configuration, _ExecutionPolicy>;
405	using _Ref = __iter_reference<_ForwardIterator>;	405	using _Ref = __iterator_reference<_ForwardIterator>;
406	auto __res =	406	auto __res =
407	_Transform()(__policy, std::move(__first), std::move(__last), std::move(__out_it), [&](_Ref __element) {	407	_Transform()(__policy, std::move(__first), std::move(__last), std::move(__out_it), [&](_Ref __element) {
408	return __pred(__element) ? __new_value : __element;	408	return __pred(__element) ? __new_value : __element;
...	@@ -424,7 +424,7 @@ struct __replace_copy<__default_backend_tag, _ExecutionPolicy> {	...	@@ -424,7 +424,7 @@ struct __replace_copy<__default_backend_tag, _ExecutionPolicy> {
424	_Tp const& __old_value,	424	_Tp const& __old_value,
425	_Tp const& __new_value) const noexcept {	425	_Tp const& __new_value) const noexcept {
426	using _ReplaceCopyIf = __dispatch<__replace_copy_if, __current_configuration, _ExecutionPolicy>;	426	using _ReplaceCopyIf = __dispatch<__replace_copy_if, __current_configuration, _ExecutionPolicy>;
427	using _Ref = __iter_reference<_ForwardIterator>;	427	using _Ref = __iterator_reference<_ForwardIterator>;
428	return _ReplaceCopyIf()(	428	return _ReplaceCopyIf()(
429	__policy,	429	__policy,
430	std::move(__first),	430	std::move(__first),

...	@@ -48,27 +48,27 @@ public:	...	@@ -48,27 +48,27 @@ public:
48		48
49	_LIBCPP_HIDE_FROM_ABI constexpr explicit as_rvalue_view(_View __base) : __base_(std::move(__base)) {}	49	_LIBCPP_HIDE_FROM_ABI constexpr explicit as_rvalue_view(_View __base) : __base_(std::move(__base)) {}
50		50
51	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&	51	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
52	requires copy_constructible<_View>	52	requires copy_constructible<_View>
53	{	53	{
54	return __base_;	54	return __base_;
55	}	55	}
56		56
57	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	57	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
58		58
59	_LIBCPP_HIDE_FROM_ABI constexpr auto begin()	59	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
60	requires(!__simple_view<_View>)	60	requires(!__simple_view<_View>)
61	{	61	{
62	return move_iterator(ranges::begin(__base_));	62	return move_iterator(ranges::begin(__base_));
63	}	63	}
64		64
65	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const	65	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
66	requires range<const _View>	66	requires range<const _View>
67	{	67	{
68	return move_iterator(ranges::begin(__base_));	68	return move_iterator(ranges::begin(__base_));
69	}	69	}
70		70
71	_LIBCPP_HIDE_FROM_ABI constexpr auto end()	71	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end()
72	requires(!__simple_view<_View>)	72	requires(!__simple_view<_View>)
73	{	73	{
74	if constexpr (common_range<_View>) {	74	if constexpr (common_range<_View>) {
...	@@ -78,7 +78,7 @@ public:	...	@@ -78,7 +78,7 @@ public:
78	}	78	}
79	}	79	}
80		80
81	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const	81	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
82	requires range<const _View>	82	requires range<const _View>
83	{	83	{
84	if constexpr (common_range<const _View>) {	84	if constexpr (common_range<const _View>) {
...	@@ -88,13 +88,13 @@ public:	...	@@ -88,13 +88,13 @@ public:
88	}	88	}
89	}	89	}
90		90
91	_LIBCPP_HIDE_FROM_ABI constexpr auto size()	91	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
92	requires sized_range<_View>	92	requires sized_range<_View>
93	{	93	{
94	return ranges::size(__base_);	94	return ranges::size(__base_);
95	}	95	}
96		96
97	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	97	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
98	requires sized_range<const _View>	98	requires sized_range<const _View>
99	{	99	{
100	return ranges::size(__base_);	100	return ranges::size(__base_);
...	@@ -117,7 +117,7 @@ struct __fn : __range_adaptor_closure<__fn> {	...	@@ -117,7 +117,7 @@ struct __fn : __range_adaptor_closure<__fn> {
117	return /---------------------------------/ as_rvalue_view(std::forward<_Range>(__range));	117	return /---------------------------------/ as_rvalue_view(std::forward<_Range>(__range));
118	}	118	}
119		119
120	template <class _Range>	120	template <input_range _Range>
121	requires same_as<range_rvalue_reference_t<_Range>, range_reference_t<_Range>>	121	requires same_as<range_rvalue_reference_t<_Range>, range_reference_t<_Range>>
122	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto	122	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI static constexpr auto
123	operator()(_Range&& __range) noexcept(noexcept(views::all(std::forward<_Range>(__range))))	123	operator()(_Range&& __range) noexcept(noexcept(views::all(std::forward<_Range>(__range))))

...	@@ -100,17 +100,17 @@ public:	...	@@ -100,17 +100,17 @@ public:
100	_LIBCPP_HIDE_FROM_ABI constexpr explicit chunk_by_view(_View __base, _Pred __pred)	100	_LIBCPP_HIDE_FROM_ABI constexpr explicit chunk_by_view(_View __base, _Pred __pred)
101	: __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}	101	: __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
102		102
103	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&	103	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
104	requires copy_constructible<_View>	104	requires copy_constructible<_View>
105	{	105	{
106	return __base_;	106	return __base_;
107	}	107	}
108		108
109	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	109	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
110		110
111	_LIBCPP_HIDE_FROM_ABI constexpr const _Pred& pred() const { return *__pred_; }	111	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Pred& pred() const { return *__pred_; }
112		112
113	_LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {	113	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
114	// Note: this duplicates a check in `optional` but provides a better error message.	114	// Note: this duplicates a check in `optional` but provides a better error message.
115	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	115	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
116	__pred_.__has_value(), "Trying to call begin() on a chunk_by_view that does not have a valid predicate.");	116	__pred_.__has_value(), "Trying to call begin() on a chunk_by_view that does not have a valid predicate.");
...	@@ -122,7 +122,7 @@ public:	...	@@ -122,7 +122,7 @@ public:
122	return {this, std::move(__first), __cached_begin_};	122	return {this, std::move(__first), __cached_begin_};
123	}	123	}
124		124
125	_LIBCPP_HIDE_FROM_ABI constexpr auto end() {	125	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
126	if constexpr (common_range<_View>) {	126	if constexpr (common_range<_View>) {
127	return __iterator{*this, ranges::end(__base_), ranges::end(__base_)};	127	return __iterator{*this, ranges::end(__base_), ranges::end(__base_)};
128	} else {	128	} else {
...	@@ -155,7 +155,7 @@ public:	...	@@ -155,7 +155,7 @@ public:
155		155
156	_LIBCPP_HIDE_FROM_ABI __iterator() = default;	156	_LIBCPP_HIDE_FROM_ABI __iterator() = default;
157		157
158	_LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const {	158	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr value_type operator*() const {
159	// If the iterator is at end, this would return an empty range which can be checked by the calling code and doesn't	159	// If the iterator is at end, this would return an empty range which can be checked by the calling code and doesn't
160	// necessarily lead to a bad access.	160	// necessarily lead to a bad access.
161	_LIBCPP_ASSERT_PEDANTIC(__current_ != __next_, "Trying to dereference past-the-end chunk_by_view iterator.");	161	_LIBCPP_ASSERT_PEDANTIC(__current_ != __next_, "Trying to dereference past-the-end chunk_by_view iterator.");

...	@@ -56,16 +56,16 @@ public:	...	@@ -56,16 +56,16 @@ public:
56	return __base_;	56	return __base_;
57	}	57	}
58		58
59	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	59	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
60		60
61	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() {	61	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
62	if constexpr (random_access_range<_View> && sized_range<_View>)	62	if constexpr (random_access_range<_View> && sized_range<_View>)
63	return ranges::begin(__base_);	63	return ranges::begin(__base_);
64	else	64	else
65	return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::begin(__base_));	65	return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::begin(__base_));
66	}	66	}
67		67
68	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const	68	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
69	requires range<const _View>	69	requires range<const _View>
70	{	70	{
71	if constexpr (random_access_range<const _View> && sized_range<const _View>)	71	if constexpr (random_access_range<const _View> && sized_range<const _View>)
...	@@ -74,14 +74,14 @@ public:	...	@@ -74,14 +74,14 @@ public:
74	return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::begin(__base_));	74	return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::begin(__base_));
75	}	75	}
76		76
77	_LIBCPP_HIDE_FROM_ABI constexpr auto end() {	77	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
78	if constexpr (random_access_range<_View> && sized_range<_View>)	78	if constexpr (random_access_range<_View> && sized_range<_View>)
79	return ranges::begin(__base_) + ranges::size(__base_);	79	return ranges::begin(__base_) + ranges::size(__base_);
80	else	80	else
81	return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::end(__base_));	81	return common_iterator<iterator_t<_View>, sentinel_t<_View>>(ranges::end(__base_));
82	}	82	}
83		83
84	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const	84	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
85	requires range<const _View>	85	requires range<const _View>
86	{	86	{
87	if constexpr (random_access_range<const _View> && sized_range<const _View>)	87	if constexpr (random_access_range<const _View> && sized_range<const _View>)
...	@@ -90,13 +90,13 @@ public:	...	@@ -90,13 +90,13 @@ public:
90	return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::end(__base_));	90	return common_iterator<iterator_t<const _View>, sentinel_t<const _View>>(ranges::end(__base_));
91	}	91	}
92		92
93	_LIBCPP_HIDE_FROM_ABI constexpr auto size()	93	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
94	requires sized_range<_View>	94	requires sized_range<_View>
95	{	95	{
96	return ranges::size(__base_);	96	return ranges::size(__base_);
97	}	97	}
98		98
99	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	99	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
100	requires sized_range<const _View>	100	requires sized_range<const _View>
101	{	101	{
102	return ranges::size(__base_);	102	return ranges::size(__base_);

...	@@ -80,14 +80,14 @@ public:	...	@@ -80,14 +80,14 @@ public:
80	_LIBCPP_ASSERT_UNCATEGORIZED(__count_ >= 0, "count must be greater than or equal to zero.");	80	_LIBCPP_ASSERT_UNCATEGORIZED(__count_ >= 0, "count must be greater than or equal to zero.");
81	}	81	}
82		82
83	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&	83	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
84	requires copy_constructible<_View>	84	requires copy_constructible<_View>
85	{	85	{
86	return __base_;	86	return __base_;
87	}	87	}
88	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	88	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
89		89
90	_LIBCPP_HIDE_FROM_ABI constexpr auto begin()	90	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
91	requires(!(__simple_view<_View> && random_access_range<const _View> && sized_range<const _View>))	91	requires(!(__simple_view<_View> && random_access_range<const _View> && sized_range<const _View>))
92	{	92	{
93	if constexpr (random_access_range<_View> && sized_range<_View>) {	93	if constexpr (random_access_range<_View> && sized_range<_View>) {
...	@@ -104,20 +104,20 @@ public:	...	@@ -104,20 +104,20 @@ public:
104	return __tmp;	104	return __tmp;
105	}	105	}
106		106
107	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const	107	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
108	requires random_access_range<const _View> && sized_range<const _View>	108	requires random_access_range<const _View> && sized_range<const _View>
109	{	109	{
110	const auto __dist = std::min(ranges::distance(__base_), __count_);	110	const auto __dist = std::min(ranges::distance(__base_), __count_);
111	return ranges::begin(__base_) + __dist;	111	return ranges::begin(__base_) + __dist;
112	}	112	}
113		113
114	_LIBCPP_HIDE_FROM_ABI constexpr auto end()	114	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end()
115	requires(!__simple_view<_View>)	115	requires(!__simple_view<_View>)
116	{	116	{
117	return ranges::end(__base_);	117	return ranges::end(__base_);
118	}	118	}
119		119
120	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const	120	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
121	requires range<const _View>	121	requires range<const _View>
122	{	122	{
123	return ranges::end(__base_);	123	return ranges::end(__base_);
...	@@ -129,13 +129,13 @@ public:	...	@@ -129,13 +129,13 @@ public:
129	return __s < __c ? 0 : __s - __c;	129	return __s < __c ? 0 : __s - __c;
130	}	130	}
131		131
132	_LIBCPP_HIDE_FROM_ABI constexpr auto size()	132	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
133	requires sized_range<_View>	133	requires sized_range<_View>
134	{	134	{
135	return __size(*this);	135	return __size(*this);
136	}	136	}
137		137
138	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	138	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
139	requires sized_range<const _View>	139	requires sized_range<const _View>
140	{	140	{
141	return __size(*this);	141	return __size(*this);

...	@@ -57,17 +57,17 @@ public:	...	@@ -57,17 +57,17 @@ public:
57	_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 drop_while_view(_View __base, _Pred __pred)	57	_LIBCPP_HIDE_FROM_ABI constexpr _LIBCPP_EXPLICIT_SINCE_CXX23 drop_while_view(_View __base, _Pred __pred)
58	: __base_(std::move(__base)), __pred_(std::in_place, std::move(__pred)) {}	58	: __base_(std::move(__base)), __pred_(std::in_place, std::move(__pred)) {}
59		59
60	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&	60	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
61	requires copy_constructible<_View>	61	requires copy_constructible<_View>
62	{	62	{
63	return __base_;	63	return __base_;
64	}	64	}
65		65
66	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	66	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
67		67
68	_LIBCPP_HIDE_FROM_ABI constexpr const _Pred& pred() const { return *__pred_; }	68	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Pred& pred() const { return *__pred_; }
69		69
70	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() {	70	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() {
71	// Note: this duplicates a check in `optional` but provides a better error message.	71	// Note: this duplicates a check in `optional` but provides a better error message.
72	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	72	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
73	__pred_.__has_value(),	73	__pred_.__has_value(),
...	@@ -83,7 +83,7 @@ public:	...	@@ -83,7 +83,7 @@ public:
83	}	83	}
84	}	84	}
85		85
86	_LIBCPP_HIDE_FROM_ABI constexpr auto end() { return ranges::end(__base_); }	86	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() { return ranges::end(__base_); }
87		87
88	private:	88	private:
89	_LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();	89	_LIBCPP_NO_UNIQUE_ADDRESS _View __base_ = _View();

...	@@ -76,16 +76,16 @@ public:	...	@@ -76,16 +76,16 @@ public:
76	: __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}	76	: __base_(std::move(__base)), __pred_(in_place, std::move(__pred)) {}
77		77
78	template <class _Vp = _View>	78	template <class _Vp = _View>
79	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&	79	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
80	requires copy_constructible<_Vp>	80	requires copy_constructible<_Vp>
81	{	81	{
82	return __base_;	82	return __base_;
83	}	83	}
84	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	84	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
85		85
86	_LIBCPP_HIDE_FROM_ABI constexpr _Pred const& pred() const { return *__pred_; }	86	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Pred const& pred() const { return *__pred_; }
87		87
88	_LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {	88	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr __iterator begin() {
89	// Note: this duplicates a check in `optional` but provides a better error message.	89	// Note: this duplicates a check in `optional` but provides a better error message.
90	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	90	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
91	__pred_.__has_value(), "Trying to call begin() on a filter_view that does not have a valid predicate.");	91	__pred_.__has_value(), "Trying to call begin() on a filter_view that does not have a valid predicate.");
...	@@ -99,7 +99,7 @@ public:	...	@@ -99,7 +99,7 @@ public:
99	}	99	}
100	}	100	}
101		101
102	_LIBCPP_HIDE_FROM_ABI constexpr auto end() {	102	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() {
103	if constexpr (common_range<_View>)	103	if constexpr (common_range<_View>)
104	return __iterator{*this, ranges::end(__base_)};	104	return __iterator{*this, ranges::end(__base_)};
105	else	105	else
...	@@ -148,10 +148,10 @@ public:	...	@@ -148,10 +148,10 @@ public:
148	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)	148	_LIBCPP_HIDE_FROM_ABI constexpr __iterator(filter_view& __parent, iterator_t<_View> __current)
149	: __current_(std::move(__current)), __parent_(std::addressof(__parent)) {}	149	: __current_(std::move(__current)), __parent_(std::addressof(__parent)) {}
150		150
151	_LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }	151	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> const& base() const& noexcept { return __current_; }
152	_LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> base() && { return std::move(__current_); }	152	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> base() && { return std::move(__current_); }
153		153
154	_LIBCPP_HIDE_FROM_ABI constexpr range_reference_t<_View> operator() const { return __current_; }	154	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr range_reference_t<_View> operator() const { return __current_; }
155	_LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> operator->() const	155	_LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_View> operator->() const
156	requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>	156	requires __has_arrow<iterator_t<_View>> && copyable<iterator_t<_View>>
157	{	157	{
...	@@ -194,7 +194,7 @@ public:	...	@@ -194,7 +194,7 @@ public:
194	return __x.__current_ == __y.__current_;	194	return __x.__current_ == __y.__current_;
195	}	195	}
196		196
197	_LIBCPP_HIDE_FROM_ABI friend constexpr range_rvalue_reference_t<_View>	197	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI friend constexpr range_rvalue_reference_t<_View>
198	iter_move(__iterator const& __it) noexcept(noexcept(ranges::iter_move(__it.__current_))) {	198	iter_move(__iterator const& __it) noexcept(noexcept(ranges::iter_move(__it.__current_))) {
199	return ranges::iter_move(__it.__current_);	199	return ranges::iter_move(__it.__current_);
200	}	200	}
...	@@ -218,7 +218,7 @@ public:	...	@@ -218,7 +218,7 @@ public:
218		218
219	_LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(filter_view& __parent) : __end_(ranges::end(__parent.__base_)) {}	219	_LIBCPP_HIDE_FROM_ABI constexpr explicit __sentinel(filter_view& __parent) : __end_(ranges::end(__parent.__base_)) {}
220		220
221	_LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_View> base() const { return __end_; }	221	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_View> base() const { return __end_; }
222		222
223	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(__iterator const& __x, __sentinel const& __y) {	223	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(__iterator const& __x, __sentinel const& __y) {
224	return __x.__current_ == __y.__end_;	224	return __x.__current_ == __y.__end_;

...	@@ -49,52 +49,52 @@ public:	...	@@ -49,52 +49,52 @@ public:
49	_LIBCPP_HIDE_FROM_ABI owning_view(owning_view&&) = default;	49	_LIBCPP_HIDE_FROM_ABI owning_view(owning_view&&) = default;
50	_LIBCPP_HIDE_FROM_ABI owning_view& operator=(owning_view&&) = default;	50	_LIBCPP_HIDE_FROM_ABI owning_view& operator=(owning_view&&) = default;
51		51
52	_LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }	52	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Rp& base() & noexcept { return __r_; }
53	_LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }	53	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Rp& base() const& noexcept { return __r_; }
54	_LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }	54	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Rp&& base() && noexcept { return std::move(__r_); }
55	_LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }	55	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr const _Rp&& base() const&& noexcept { return std::move(__r_); }
56		56
57	_LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }	57	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Rp> begin() { return ranges::begin(__r_); }
58	_LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }	58	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Rp> end() { return ranges::end(__r_); }
59	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const	59	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
60	requires range<const _Rp>	60	requires range<const _Rp>
61	{	61	{
62	return ranges::begin(__r_);	62	return ranges::begin(__r_);
63	}	63	}
64	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const	64	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
65	requires range<const _Rp>	65	requires range<const _Rp>
66	{	66	{
67	return ranges::end(__r_);	67	return ranges::end(__r_);
68	}	68	}
69		69
70	_LIBCPP_HIDE_FROM_ABI constexpr bool empty()	70	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty()
71	requires requires { ranges::empty(__r_); }	71	requires requires { ranges::empty(__r_); }
72	{	72	{
73	return ranges::empty(__r_);	73	return ranges::empty(__r_);
74	}	74	}
75	_LIBCPP_HIDE_FROM_ABI constexpr bool empty() const	75	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
76	requires requires { ranges::empty(__r_); }	76	requires requires { ranges::empty(__r_); }
77	{	77	{
78	return ranges::empty(__r_);	78	return ranges::empty(__r_);
79	}	79	}
80		80
81	_LIBCPP_HIDE_FROM_ABI constexpr auto size()	81	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
82	requires sized_range<_Rp>	82	requires sized_range<_Rp>
83	{	83	{
84	return ranges::size(__r_);	84	return ranges::size(__r_);
85	}	85	}
86	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	86	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
87	requires sized_range<const _Rp>	87	requires sized_range<const _Rp>
88	{	88	{
89	return ranges::size(__r_);	89	return ranges::size(__r_);
90	}	90	}
91		91
92	_LIBCPP_HIDE_FROM_ABI constexpr auto data()	92	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto data()
93	requires contiguous_range<_Rp>	93	requires contiguous_range<_Rp>
94	{	94	{
95	return ranges::data(__r_);	95	return ranges::data(__r_);
96	}	96	}
97	_LIBCPP_HIDE_FROM_ABI constexpr auto data() const	97	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
98	requires contiguous_range<const _Rp>	98	requires contiguous_range<const _Rp>
99	{	99	{
100	return ranges::data(__r_);	100	return ranges::data(__r_);

...	@@ -51,24 +51,24 @@ public:	...	@@ -51,24 +51,24 @@ public:
51	_LIBCPP_HIDE_FROM_ABI constexpr ref_view(_Tp&& __t)	51	_LIBCPP_HIDE_FROM_ABI constexpr ref_view(_Tp&& __t)
52	: __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t)))) {}	52	: __range_(std::addressof(static_cast<_Range&>(std::forward<_Tp>(__t)))) {}
53		53
54	_LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }	54	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _Range& base() const { return *__range_; }
55		55
56	_LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }	56	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr iterator_t<_Range> begin() const { return ranges::begin(*__range_); }
57	_LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }	57	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Range> end() const { return ranges::end(*__range_); }
58		58
59	_LIBCPP_HIDE_FROM_ABI constexpr bool empty() const	59	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr bool empty() const
60	requires requires { ranges::empty(*__range_); }	60	requires requires { ranges::empty(*__range_); }
61	{	61	{
62	return ranges::empty(*__range_);	62	return ranges::empty(*__range_);
63	}	63	}
64		64
65	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	65	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
66	requires sized_range<_Range>	66	requires sized_range<_Range>
67	{	67	{
68	return ranges::size(*__range_);	68	return ranges::size(*__range_);
69	}	69	}
70		70
71	_LIBCPP_HIDE_FROM_ABI constexpr auto data() const	71	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
72	requires contiguous_range<_Range>	72	requires contiguous_range<_Range>
73	{	73	{
74	return ranges::data(*__range_);	74	return ranges::data(*__range_);

...	@@ -75,15 +75,15 @@ public:	...	@@ -75,15 +75,15 @@ public:
75	_LIBCPP_ASSERT_UNCATEGORIZED(__count >= 0, "count has to be greater than or equal to zero");	75	_LIBCPP_ASSERT_UNCATEGORIZED(__count >= 0, "count has to be greater than or equal to zero");
76	}	76	}
77		77
78	_LIBCPP_HIDE_FROM_ABI constexpr _View base() const&	78	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() const&
79	requires copy_constructible<_View>	79	requires copy_constructible<_View>
80	{	80	{
81	return __base_;	81	return __base_;
82	}	82	}
83		83
84	_LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }	84	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr _View base() && { return std::move(__base_); }
85		85
86	_LIBCPP_HIDE_FROM_ABI constexpr auto begin()	86	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin()
87	requires(!__simple_view<_View>)	87	requires(!__simple_view<_View>)
88	{	88	{
89	if constexpr (sized_range<_View>) {	89	if constexpr (sized_range<_View>) {
...	@@ -99,7 +99,7 @@ public:	...	@@ -99,7 +99,7 @@ public:
99	}	99	}
100	}	100	}
101		101
102	_LIBCPP_HIDE_FROM_ABI constexpr auto begin() const	102	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto begin() const
103	requires range<const _View>	103	requires range<const _View>
104	{	104	{
105	if constexpr (sized_range<const _View>) {	105	if constexpr (sized_range<const _View>) {
...	@@ -115,7 +115,7 @@ public:	...	@@ -115,7 +115,7 @@ public:
115	}	115	}
116	}	116	}
117		117
118	_LIBCPP_HIDE_FROM_ABI constexpr auto end()	118	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end()
119	requires(!__simple_view<_View>)	119	requires(!__simple_view<_View>)
120	{	120	{
121	if constexpr (sized_range<_View>) {	121	if constexpr (sized_range<_View>) {
...	@@ -129,7 +129,7 @@ public:	...	@@ -129,7 +129,7 @@ public:
129	}	129	}
130	}	130	}
131		131
132	_LIBCPP_HIDE_FROM_ABI constexpr auto end() const	132	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto end() const
133	requires range<const _View>	133	requires range<const _View>
134	{	134	{
135	if constexpr (sized_range<const _View>) {	135	if constexpr (sized_range<const _View>) {
...	@@ -143,14 +143,14 @@ public:	...	@@ -143,14 +143,14 @@ public:
143	}	143	}
144	}	144	}
145		145
146	_LIBCPP_HIDE_FROM_ABI constexpr auto size()	146	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
147	requires sized_range<_View>	147	requires sized_range<_View>
148	{	148	{
149	auto __n = ranges::size(__base_);	149	auto __n = ranges::size(__base_);
150	return ranges::min(__n, static_cast<decltype(__n)>(__count_));	150	return ranges::min(__n, static_cast<decltype(__n)>(__count_));
151	}	151	}
152		152
153	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	153	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
154	requires sized_range<const _View>	154	requires sized_range<const _View>
155	{	155	{
156	auto __n = ranges::size(__base_);	156	auto __n = ranges::size(__base_);
...	@@ -178,7 +178,7 @@ public:	...	@@ -178,7 +178,7 @@ public:
178	requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>	178	requires _Const && convertible_to<sentinel_t<_View>, sentinel_t<_Base>>
179	: __end_(std::move(__s.__end_)) {}	179	: __end_(std::move(__s.__end_)) {}
180		180
181	_LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }	181	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr sentinel_t<_Base> base() const { return __end_; }
182		182
183	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {	183	_LIBCPP_HIDE_FROM_ABI friend constexpr bool operator==(const _Iter<_Const>& __lhs, const __sentinel& __rhs) {
184	return __lhs.count() == 0 \|\| __lhs.base() == __rhs.__end_;	184	return __lhs.count() == 0 \|\| __lhs.base() == __rhs.__end_;

...	@@ -87,35 +87,35 @@ public:	...	@@ -87,35 +87,35 @@ public:
87	}	87	}
88		88
89	template <class _D2 = _Derived>	89	template <class _D2 = _Derived>
90	_LIBCPP_HIDE_FROM_ABI constexpr auto data()	90	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto data()
91	requires contiguous_iterator<iterator_t<_D2>>	91	requires contiguous_iterator<iterator_t<_D2>>
92	{	92	{
93	return std::to_address(ranges::begin(__derived()));	93	return std::to_address(ranges::begin(__derived()));
94	}	94	}
95		95
96	template <class _D2 = _Derived>	96	template <class _D2 = _Derived>
97	_LIBCPP_HIDE_FROM_ABI constexpr auto data() const	97	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto data() const
98	requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>	98	requires range<const _D2> && contiguous_iterator<iterator_t<const _D2>>
99	{	99	{
100	return std::to_address(ranges::begin(__derived()));	100	return std::to_address(ranges::begin(__derived()));
101	}	101	}
102		102
103	template <class _D2 = _Derived>	103	template <class _D2 = _Derived>
104	_LIBCPP_HIDE_FROM_ABI constexpr auto size()	104	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size()
105	requires forward_range<_D2> && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>	105	requires forward_range<_D2> && sized_sentinel_for<sentinel_t<_D2>, iterator_t<_D2>>
106	{	106	{
107	return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));	107	return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));
108	}	108	}
109		109
110	template <class _D2 = _Derived>	110	template <class _D2 = _Derived>
111	_LIBCPP_HIDE_FROM_ABI constexpr auto size() const	111	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr auto size() const
112	requires forward_range<const _D2> && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>	112	requires forward_range<const _D2> && sized_sentinel_for<sentinel_t<const _D2>, iterator_t<const _D2>>
113	{	113	{
114	return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));	114	return std::__to_unsigned_like(ranges::end(__derived()) - ranges::begin(__derived()));
115	}	115	}
116		116
117	template <class _D2 = _Derived>	117	template <class _D2 = _Derived>
118	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front()	118	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front()
119	requires forward_range<_D2>	119	requires forward_range<_D2>
120	{	120	{
121	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	121	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
...	@@ -124,7 +124,7 @@ public:	...	@@ -124,7 +124,7 @@ public:
124	}	124	}
125		125
126	template <class _D2 = _Derived>	126	template <class _D2 = _Derived>
127	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front() const	127	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) front() const
128	requires forward_range<const _D2>	128	requires forward_range<const _D2>
129	{	129	{
130	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	130	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
...	@@ -133,7 +133,7 @@ public:	...	@@ -133,7 +133,7 @@ public:
133	}	133	}
134		134
135	template <class _D2 = _Derived>	135	template <class _D2 = _Derived>
136	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back()	136	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back()
137	requires bidirectional_range<_D2> && common_range<_D2>	137	requires bidirectional_range<_D2> && common_range<_D2>
138	{	138	{
139	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	139	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
...	@@ -142,7 +142,7 @@ public:	...	@@ -142,7 +142,7 @@ public:
142	}	142	}
143		143
144	template <class _D2 = _Derived>	144	template <class _D2 = _Derived>
145	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back() const	145	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) back() const
146	requires bidirectional_range<const _D2> && common_range<const _D2>	146	requires bidirectional_range<const _D2> && common_range<const _D2>
147	{	147	{
148	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(	148	_LIBCPP_ASSERT_VALID_ELEMENT_ACCESS(
...	@@ -151,12 +151,12 @@ public:	...	@@ -151,12 +151,12 @@ public:
151	}	151	}
152		152
153	template <random_access_range _RARange = _Derived>	153	template <random_access_range _RARange = _Derived>
154	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) {	154	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) {
155	return ranges::begin(__derived())[__index];	155	return ranges::begin(__derived())[__index];
156	}	156	}
157		157
158	template <random_access_range _RARange = const _Derived>	158	template <random_access_range _RARange = const _Derived>
159	_LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const {	159	[[nodiscard]] _LIBCPP_HIDE_FROM_ABI constexpr decltype(auto) operator[](range_difference_t<_RARange> __index) const {
160	return ranges::begin(__derived())[__index];	160	return ranges::begin(__derived())[__index];
161	}	161	}
162	};	162	};

...	@@ -100,7 +100,7 @@ public:	...	@@ -100,7 +100,7 @@ public:
100	return ((__curent_state & __stop_requested_bit) != 0) \|\| ((__curent_state >> __stop_source_counter_shift) != 0);	100	return ((__curent_state & __stop_requested_bit) != 0) \|\| ((__curent_state >> __stop_source_counter_shift) != 0);
101	}	101	}
102		102
103	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __request_stop() noexcept {	103	_LIBCPP_HIDE_FROM_ABI bool __request_stop() noexcept {
104	auto __cb_list_lock = __try_lock_for_request_stop();	104	auto __cb_list_lock = __try_lock_for_request_stop();
105	if (!__cb_list_lock.__owns_lock()) {	105	if (!__cb_list_lock.__owns_lock()) {
106	return false;	106	return false;
...	@@ -137,7 +137,7 @@ public:	...	@@ -137,7 +137,7 @@ public:
137	return true;	137	return true;
138	}	138	}
139		139
140	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI bool __add_callback(__stop_callback_base* __cb) noexcept {	140	_LIBCPP_HIDE_FROM_ABI bool __add_callback(__stop_callback_base* __cb) noexcept {
141	// If it is already stop_requested. Do not try to request it again.	141	// If it is already stop_requested. Do not try to request it again.
142	const auto __give_up_trying_to_lock_condition = [__cb](__state_t __state) {	142	const auto __give_up_trying_to_lock_condition = [__cb](__state_t __state) {
143	if ((__state & __stop_requested_bit) != 0) {	143	if ((__state & __stop_requested_bit) != 0) {
...	@@ -164,7 +164,7 @@ public:	...	@@ -164,7 +164,7 @@ public:
164	}	164	}
165		165
166	// called by the destructor of stop_callback	166	// called by the destructor of stop_callback
167	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI void __remove_callback(__stop_callback_base* __cb) noexcept {	167	_LIBCPP_HIDE_FROM_ABI void __remove_callback(__stop_callback_base* __cb) noexcept {
168	__callback_list_lock __cb_list_lock(__state_);	168	__callback_list_lock __cb_list_lock(__state_);
169		169
170	// under below condition, the request_stop call just popped __cb from the list and could execute it now	170	// under below condition, the request_stop call just popped __cb from the list and could execute it now
...	@@ -192,7 +192,7 @@ public:	...	@@ -192,7 +192,7 @@ public:
192	}	192	}
193		193
194	private:	194	private:
195	_LIBCPP_AVAILABILITY_SYNC _LIBCPP_HIDE_FROM_ABI __callback_list_lock __try_lock_for_request_stop() noexcept {	195	_LIBCPP_HIDE_FROM_ABI __callback_list_lock __try_lock_for_request_stop() noexcept {
196	// If it is already stop_requested, do not try to request stop or lock the list again.	196	// If it is already stop_requested, do not try to request stop or lock the list again.
197	const auto __lock_fail_condition = [](__state_t __state) { return (__state & __stop_requested_bit) != 0; };	197	const auto __lock_fail_condition = [](__state_t __state) { return (__state & __stop_requested_bit) != 0; };
198		198

...	@@ -20,7 +20,7 @@	...	@@ -20,7 +20,7 @@
20		20
21	_LIBCPP_BEGIN_NAMESPACE_STD	21	_LIBCPP_BEGIN_NAMESPACE_STD
22		22
23	class _LIBCPP_EXPORTED_FROM_ABI error_condition;	23	class error_condition;
24	class _LIBCPP_EXPORTED_FROM_ABI error_code;	24	class _LIBCPP_EXPORTED_FROM_ABI error_code;
25		25
26	class _LIBCPP_HIDDEN __do_message;	26	class _LIBCPP_HIDDEN __do_message;
...	@@ -37,11 +37,11 @@ public:	...	@@ -37,11 +37,11 @@ public:
37	error_category(const error_category&) = delete;	37	error_category(const error_category&) = delete;
38	error_category& operator=(const error_category&) = delete;	38	error_category& operator=(const error_category&) = delete;
39		39
40	virtual const char* name() const _NOEXCEPT = 0;	40	[[__nodiscard__]] virtual const char* name() const _NOEXCEPT = 0;
41	virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;	41	[[__nodiscard__]] virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
42	virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;	42	[[__nodiscard__]] virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
43	virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;	43	[[__nodiscard__]] virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
44	virtual string message(int __ev) const = 0;	44	[[__nodiscard__]] virtual string message(int __ev) const = 0;
45		45
46	_LIBCPP_HIDE_FROM_ABI bool operator==(const error_category& __rhs) const _NOEXCEPT { return this == &__rhs; }	46	_LIBCPP_HIDE_FROM_ABI bool operator==(const error_category& __rhs) const _NOEXCEPT { return this == &__rhs; }
47		47
...	@@ -67,8 +67,8 @@ public:	...	@@ -67,8 +67,8 @@ public:
67	string message(int __ev) const override;	67	string message(int __ev) const override;
68	};	68	};
69		69
70	[[__gnu__::__const__]] _LIBCPP_EXPORTED_FROM_ABI const error_category& generic_category() _NOEXCEPT;	70	[[__gnu__::__const__]] [[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI const error_category& generic_category() _NOEXCEPT;
71	[[__gnu__::__const__]] _LIBCPP_EXPORTED_FROM_ABI const error_category& system_category() _NOEXCEPT;	71	[[__gnu__::__const__]] [[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI const error_category& system_category() _NOEXCEPT;
72		72
73	_LIBCPP_END_NAMESPACE_STD	73	_LIBCPP_END_NAMESPACE_STD
74		74

...	@@ -39,17 +39,17 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursiv	...	@@ -39,17 +39,17 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursiv
39	return mtx_init(__m, mtx_plain \| mtx_recursive) == thrd_success ? 0 : EINVAL;	39	return mtx_init(__m, mtx_plain \| mtx_recursive) == thrd_success ? 0 : EINVAL;
40	}	40	}
41		41
42	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	42	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
43	__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m) {	43	__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m) {
44	return mtx_lock(__m) == thrd_success ? 0 : EINVAL;	44	return mtx_lock(__m) == thrd_success ? 0 : EINVAL;
45	}	45	}
46		46
47	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool	47	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI bool
48	__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m) {	48	__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m) {
49	return mtx_trylock(__m) == thrd_success;	49	return mtx_trylock(__m) == thrd_success;
50	}	50	}
51		51
52	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	52	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
53	__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m) {	53	__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m) {
54	return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;	54	return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;
55	}	55	}
...	@@ -59,15 +59,15 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recur	...	@@ -59,15 +59,15 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recur
59	return 0;	59	return 0;
60	}	60	}
61		61
62	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_lock(__libcpp_mutex_t* __m) {	62	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int __libcpp_mutex_lock(__libcpp_mutex_t* __m) {
63	return mtx_lock(__m) == thrd_success ? 0 : EINVAL;	63	return mtx_lock(__m) == thrd_success ? 0 : EINVAL;
64	}	64	}
65		65
66	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m) {	66	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m) {
67	return mtx_trylock(__m) == thrd_success;	67	return mtx_trylock(__m) == thrd_success;
68	}	68	}
69		69
70	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_unlock(__libcpp_mutex_t* __m) {	70	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int __libcpp_mutex_unlock(__libcpp_mutex_t* __m) {
71	return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;	71	return mtx_unlock(__m) == thrd_success ? 0 : EINVAL;
72	}	72	}
73		73
...	@@ -92,12 +92,12 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t*	...	@@ -92,12 +92,12 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t*
92	return cnd_broadcast(__cv) == thrd_success ? 0 : EINVAL;	92	return cnd_broadcast(__cv) == thrd_success ? 0 : EINVAL;
93	}	93	}
94		94
95	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	95	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
96	__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m) {	96	__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m) {
97	return cnd_wait(__cv, __m) == thrd_success ? 0 : EINVAL;	97	return cnd_wait(__cv, __m) == thrd_success ? 0 : EINVAL;
98	}	98	}
99		99
100	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	100	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
101	__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, timespec* __ts) {	101	__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, timespec* __ts) {
102	int __ec = cnd_timedwait(__cv, __m, __ts);	102	int __ec = cnd_timedwait(__cv, __m, __ts);
103	return __ec == thrd_timedout ? ETIMEDOUT : __ec;	103	return __ec == thrd_timedout ? ETIMEDOUT : __ec;

libcxx: update to LLVM 22

...	@@ -72,17 +72,17 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursiv	...	@@ -72,17 +72,17 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursiv
72	return 0;	72	return 0;
73	}	73	}
74		74
75	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	75	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
76	__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m) {	76	__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m) {
77	return pthread_mutex_lock(__m);	77	return pthread_mutex_lock(__m);
78	}	78	}
79		79
80	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool	80	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI bool
81	__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m) {	81	__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m) {
82	return pthread_mutex_trylock(__m) == 0;	82	return pthread_mutex_trylock(__m) == 0;
83	}	83	}
84		84
85	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	85	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
86	__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m) {	86	__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m) {
87	return pthread_mutex_unlock(__m);	87	return pthread_mutex_unlock(__m);
88	}	88	}
...	@@ -91,15 +91,15 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recur	...	@@ -91,15 +91,15 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recur
91	return pthread_mutex_destroy(__m);	91	return pthread_mutex_destroy(__m);
92	}	92	}
93		93
94	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_lock(__libcpp_mutex_t* __m) {	94	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int __libcpp_mutex_lock(__libcpp_mutex_t* __m) {
95	return pthread_mutex_lock(__m);	95	return pthread_mutex_lock(__m);
96	}	96	}
97		97
98	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m) {	98	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m) {
99	return pthread_mutex_trylock(__m) == 0;	99	return pthread_mutex_trylock(__m) == 0;
100	}	100	}
101		101
102	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_unlock(__libcpp_mutex_t* __m) {	102	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int __libcpp_mutex_unlock(__libcpp_mutex_t* __m) {
103	return pthread_mutex_unlock(__m);	103	return pthread_mutex_unlock(__m);
104	}	104	}
105		105
...	@@ -117,12 +117,12 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t*	...	@@ -117,12 +117,12 @@ inline _LIBCPP_HIDE_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t*
117	return pthread_cond_broadcast(__cv);	117	return pthread_cond_broadcast(__cv);
118	}	118	}
119		119
120	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	120	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
121	__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m) {	121	__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m) {
122	return pthread_cond_wait(__cv, __m);	122	return pthread_cond_wait(__cv, __m);
123	}	123	}
124		124
125	inline _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	125	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS inline _LIBCPP_HIDE_FROM_ABI int
126	__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, __libcpp_timespec_t* __ts) {	126	__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, __libcpp_timespec_t* __ts) {
127	return pthread_cond_timedwait(__cv, __m, __ts);	127	return pthread_cond_timedwait(__cv, __m, __ts);
128	}	128	}

...	@@ -36,22 +36,22 @@ typedef void* __libcpp_recursive_mutex_t[6];	...	@@ -36,22 +36,22 @@ typedef void* __libcpp_recursive_mutex_t[6];
36		36
37	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t* __m);	37	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_recursive_mutex_init(__libcpp_recursive_mutex_t* __m);
38		38
39	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	39	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
40	__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m);	40	__libcpp_recursive_mutex_lock(__libcpp_recursive_mutex_t* __m);
41		41
42	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool	42	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI bool
43	__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m);	43	__libcpp_recursive_mutex_trylock(__libcpp_recursive_mutex_t* __m);
44		44
45	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	45	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
46	__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m);	46	__libcpp_recursive_mutex_unlock(__libcpp_recursive_mutex_t* __m);
47		47
48	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t* __m);	48	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_recursive_mutex_destroy(__libcpp_recursive_mutex_t* __m);
49		49
50	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_lock(__libcpp_mutex_t* __m);	50	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int __libcpp_mutex_lock(__libcpp_mutex_t* __m);
51		51
52	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m);	52	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI bool __libcpp_mutex_trylock(__libcpp_mutex_t* __m);
53		53
54	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int __libcpp_mutex_unlock(__libcpp_mutex_t* __m);	54	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int __libcpp_mutex_unlock(__libcpp_mutex_t* __m);
55		55
56	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_mutex_destroy(__libcpp_mutex_t* __m);	56	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_mutex_destroy(__libcpp_mutex_t* __m);
57		57
...	@@ -65,10 +65,10 @@ _LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_signal(__libcpp_condvar_t* __cv);	...	@@ -65,10 +65,10 @@ _LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_signal(__libcpp_condvar_t* __cv);
65		65
66	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv);	66	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_broadcast(__libcpp_condvar_t* __cv);
67		67
68	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	68	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
69	__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);	69	__libcpp_condvar_wait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m);
70		70
71	_LIBCPP_EXPORTED_FROM_ABI _LIBCPP_NO_THREAD_SAFETY_ANALYSIS int	71	_LIBCPP_NO_THREAD_SAFETY_ANALYSIS _LIBCPP_EXPORTED_FROM_ABI int
72	__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, __libcpp_timespec_t* __ts);	72	__libcpp_condvar_timedwait(__libcpp_condvar_t* __cv, __libcpp_mutex_t* __m, __libcpp_timespec_t* __ts);
73		73
74	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);	74	_LIBCPP_EXPORTED_FROM_ABI int __libcpp_condvar_destroy(__libcpp_condvar_t* __cv);

...	@@ -305,25 +305,25 @@ public:	...	@@ -305,25 +305,25 @@ public:
305	class _LIBCPP_EXPORTED_FROM_ABI Init;	305	class _LIBCPP_EXPORTED_FROM_ABI Init;
306		306
307	// 27.5.2.2 fmtflags state:	307	// 27.5.2.2 fmtflags state:
308	_LIBCPP_HIDE_FROM_ABI fmtflags flags() const;	308	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI fmtflags flags() const;
309	_LIBCPP_HIDE_FROM_ABI fmtflags flags(fmtflags __fmtfl);	309	_LIBCPP_HIDE_FROM_ABI fmtflags flags(fmtflags __fmtfl);
310	_LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl);	310	_LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl);
311	_LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl, fmtflags __mask);	311	_LIBCPP_HIDE_FROM_ABI fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
312	_LIBCPP_HIDE_FROM_ABI void unsetf(fmtflags __mask);	312	_LIBCPP_HIDE_FROM_ABI void unsetf(fmtflags __mask);
313		313
314	_LIBCPP_HIDE_FROM_ABI streamsize precision() const;	314	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI streamsize precision() const;
315	_LIBCPP_HIDE_FROM_ABI streamsize precision(streamsize __prec);	315	_LIBCPP_HIDE_FROM_ABI streamsize precision(streamsize __prec);
316	_LIBCPP_HIDE_FROM_ABI streamsize width() const;	316	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI streamsize width() const;
317	_LIBCPP_HIDE_FROM_ABI streamsize width(streamsize __wide);	317	_LIBCPP_HIDE_FROM_ABI streamsize width(streamsize __wide);
318		318
319	// 27.5.2.3 locales:	319	// 27.5.2.3 locales:
320	locale imbue(const locale& __loc);	320	locale imbue(const locale& __loc);
321	locale getloc() const;	321	[[__nodiscard__]] locale getloc() const;
322		322
323	// 27.5.2.5 storage:	323	// 27.5.2.5 storage:
324	static int xalloc();	324	[[__nodiscard__]] static int xalloc();
325	long& iword(int __index);	325	[[__nodiscard__]] long& iword(int __index);
326	void*& pword(int __index);	326	[[__nodiscard__]] void*& pword(int __index);
327		327
328	// destructor	328	// destructor
329	virtual ~ios_base();	329	virtual ~ios_base();
...	@@ -338,16 +338,16 @@ public:	...	@@ -338,16 +338,16 @@ public:
338		338
339	static bool sync_with_stdio(bool __sync = true);	339	static bool sync_with_stdio(bool __sync = true);
340		340
341	_LIBCPP_HIDE_FROM_ABI iostate rdstate() const;	341	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iostate rdstate() const;
342	void clear(iostate __state = goodbit);	342	void clear(iostate __state = goodbit);
343	_LIBCPP_HIDE_FROM_ABI void setstate(iostate __state);	343	_LIBCPP_HIDE_FROM_ABI void setstate(iostate __state);
344		344
345	_LIBCPP_HIDE_FROM_ABI bool good() const;	345	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool good() const;
346	_LIBCPP_HIDE_FROM_ABI bool eof() const;	346	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool eof() const;
347	_LIBCPP_HIDE_FROM_ABI bool fail() const;	347	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool fail() const;
348	_LIBCPP_HIDE_FROM_ABI bool bad() const;	348	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool bad() const;
349		349
350	_LIBCPP_HIDE_FROM_ABI iostate exceptions() const;	350	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iostate exceptions() const;
351	_LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate);	351	_LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate);
352		352
353	void __set_badbit_and_consider_rethrow();	353	void __set_badbit_and_consider_rethrow();
...	@@ -425,13 +425,13 @@ template <>	...	@@ -425,13 +425,13 @@ template <>
425	struct is_error_code_enum<io_errc::__lx> : public true_type {};	425	struct is_error_code_enum<io_errc::__lx> : public true_type {};
426	# endif	426	# endif
427		427
428	_LIBCPP_EXPORTED_FROM_ABI const error_category& iostream_category() _NOEXCEPT;	428	[[__nodiscard__]] _LIBCPP_EXPORTED_FROM_ABI const error_category& iostream_category() _NOEXCEPT;
429		429
430	inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(io_errc __e) _NOEXCEPT {	430	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI error_code make_error_code(io_errc __e) _NOEXCEPT {
431	return error_code(static_cast<int>(__e), iostream_category());	431	return error_code(static_cast<int>(__e), iostream_category());
432	}	432	}
433		433
434	inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(io_errc __e) _NOEXCEPT {	434	[[__nodiscard__]] inline _LIBCPP_HIDE_FROM_ABI error_condition make_error_condition(io_errc __e) _NOEXCEPT {
435	return error_condition(static_cast<int>(__e), iostream_category());	435	return error_condition(static_cast<int>(__e), iostream_category());
436	}	436	}
437		437
...	@@ -580,16 +580,16 @@ public:	...	@@ -580,16 +580,16 @@ public:
580	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return !fail(); }	580	_LIBCPP_HIDE_FROM_ABI explicit operator bool() const { return !fail(); }
581	# endif	581	# endif
582		582
583	_LIBCPP_HIDE_FROM_ABI bool operator!() const { return fail(); }	583	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool operator!() const { return fail(); }
584	_LIBCPP_HIDE_FROM_ABI iostate rdstate() const { return ios_base::rdstate(); }	584	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iostate rdstate() const { return ios_base::rdstate(); }
585	_LIBCPP_HIDE_FROM_ABI void clear(iostate __state = goodbit) { ios_base::clear(__state); }	585	_LIBCPP_HIDE_FROM_ABI void clear(iostate __state = goodbit) { ios_base::clear(__state); }
586	_LIBCPP_HIDE_FROM_ABI void setstate(iostate __state) { ios_base::setstate(__state); }	586	_LIBCPP_HIDE_FROM_ABI void setstate(iostate __state) { ios_base::setstate(__state); }
587	_LIBCPP_HIDE_FROM_ABI bool good() const { return ios_base::good(); }	587	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool good() const { return ios_base::good(); }
588	_LIBCPP_HIDE_FROM_ABI bool eof() const { return ios_base::eof(); }	588	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool eof() const { return ios_base::eof(); }
589	_LIBCPP_HIDE_FROM_ABI bool fail() const { return ios_base::fail(); }	589	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool fail() const { return ios_base::fail(); }
590	_LIBCPP_HIDE_FROM_ABI bool bad() const { return ios_base::bad(); }	590	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI bool bad() const { return ios_base::bad(); }
591		591
592	_LIBCPP_HIDE_FROM_ABI iostate exceptions() const { return ios_base::exceptions(); }	592	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI iostate exceptions() const { return ios_base::exceptions(); }
593	_LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate) { ios_base::exceptions(__iostate); }	593	_LIBCPP_HIDE_FROM_ABI void exceptions(iostate __iostate) { ios_base::exceptions(__iostate); }
594		594
595	// 27.5.4.1 Constructor/destructor:	595	// 27.5.4.1 Constructor/destructor:
...	@@ -597,21 +597,21 @@ public:	...	@@ -597,21 +597,21 @@ public:
597	~basic_ios() override;	597	~basic_ios() override;
598		598
599	// 27.5.4.2 Members:	599	// 27.5.4.2 Members:
600	_LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie() const;	600	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie() const;
601	_LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);	601	_LIBCPP_HIDE_FROM_ABI basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);
602		602
603	_LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf() const;	603	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf() const;
604	_LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);	604	_LIBCPP_HIDE_FROM_ABI basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);
605		605
606	basic_ios& copyfmt(const basic_ios& __rhs);	606	basic_ios& copyfmt(const basic_ios& __rhs);
607		607
608	_LIBCPP_HIDE_FROM_ABI char_type fill() const;	608	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char_type fill() const;
609	_LIBCPP_HIDE_FROM_ABI char_type fill(char_type __ch);	609	_LIBCPP_HIDE_FROM_ABI char_type fill(char_type __ch);
610		610
611	_LIBCPP_HIDE_FROM_ABI locale imbue(const locale& __loc);	611	_LIBCPP_HIDE_FROM_ABI locale imbue(const locale& __loc);
612		612
613	_LIBCPP_HIDE_FROM_ABI char narrow(char_type __c, char __dfault) const;	613	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char narrow(char_type __c, char __dfault) const;
614	_LIBCPP_HIDE_FROM_ABI char_type widen(char __c) const;	614	[[__nodiscard__]] _LIBCPP_HIDE_FROM_ABI char_type widen(char __c) const;
615		615
616	protected:	616	protected:
617	_LIBCPP_HIDE_FROM_ABI basic_ios() {	617	_LIBCPP_HIDE_FROM_ABI basic_ios() {

...	@@ -107,7 +107,7 @@ template<> class numeric_limits<cv long double>;	...	@@ -107,7 +107,7 @@ template<> class numeric_limits<cv long double>;
107	#else	107	#else
108	# include <__config>	108	# include <__config>
109	# include <__type_traits/is_arithmetic.h>	109	# include <__type_traits/is_arithmetic.h>
110	# include <__type_traits/is_signed.h>	110	# include <__type_traits/is_same.h>
111		111
112	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)	112	# if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
113	# pragma GCC system_header	113	# pragma GCC system_header
...	@@ -217,10 +217,10 @@ protected:	...	@@ -217,10 +217,10 @@ protected:
217		217
218	static _LIBCPP_CONSTEXPR const bool is_iec559 = false;	218	static _LIBCPP_CONSTEXPR const bool is_iec559 = false;
219	static _LIBCPP_CONSTEXPR const bool is_bounded = true;	219	static _LIBCPP_CONSTEXPR const bool is_bounded = true;
220	static _LIBCPP_CONSTEXPR const bool is_modulo = !std::is_signed<_Tp>::value;	220	static _LIBCPP_CONSTEXPR const bool is_modulo = !is_signed;
221		221
222	# if defined(__i386__) \|\| defined(__x86_64__) \|\| defined(__pnacl__) \|\| defined(__wasm__)	222	# if defined(__i386__) \|\| defined(__x86_64__) \|\| defined(__wasm__)
223	static _LIBCPP_CONSTEXPR const bool traps = true;	223	static _LIBCPP_CONSTEXPR const bool traps = is_same<decltype(+_Tp(0)), _Tp>::value;
224	# else	224	# else
225	static _LIBCPP_CONSTEXPR const bool traps = false;	225	static _LIBCPP_CONSTEXPR const bool traps = false;
226	# endif	226	# endif