diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 1640e5dc614..54bdc1445d1 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -2681,14 +2681,13 @@ concept _Container_compatible_range =
     (_RANGES input_range<_Rng>) && convertible_to<_RANGES range_reference_t<_Rng>, _Elem>;
 
 template <_RANGES input_range _Rng>
-using _Range_key_type = remove_const_t<typename _RANGES range_value_t<_Rng>::first_type>;
+using _Range_key_type = remove_cvref_t<tuple_element_t<0, _RANGES range_value_t<_Rng>>>;
 
 template <_RANGES input_range _Rng>
-using _Range_mapped_type = _RANGES range_value_t<_Rng>::second_type;
+using _Range_mapped_type = remove_cvref_t<tuple_element_t<1, _RANGES range_value_t<_Rng>>>;
 
 template <_RANGES input_range _Rng>
-using _Range_to_alloc_type =
-    pair<const typename _RANGES range_value_t<_Rng>::first_type, typename _RANGES range_value_t<_Rng>::second_type>;
+using _Range_to_alloc_type = pair<const _Range_key_type<_Rng>, _Range_mapped_type<_Rng>>;
 #endif // _HAS_CXX23
 
 template <class _Ty,
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 488bc52d044..e3ace1bae5a 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -1702,32 +1702,25 @@ struct _Is_allocator<_Ty, void_t<typename _Ty::value_type, decltype(_STD declval
     : true_type {}; // selected when _Ty resembles an allocator, N4950 [container.reqmts]/69
 #endif // ^^^ !_HAS_CXX20 ^^^
 
-// deduction guide utilities (N4950 [associative.general]/2)
+// deduction guide utilities (N5050 [associative.general]/2)
 template <class _Iter>
 using _Guide_key_t =
 #if _HAS_CXX23
-    remove_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>;
+    remove_cvref_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>;
 #else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
-    remove_const_t<typename iterator_traits<_Iter>::value_type::first_type>;
+    _Remove_cvref_t<typename iterator_traits<_Iter>::value_type::first_type>;
 #endif // ^^^ !_HAS_CXX23 ^^^
 
 template <class _Iter>
 using _Guide_val_t =
 #if _HAS_CXX23
-    tuple_element_t<1, typename iterator_traits<_Iter>::value_type>;
+    remove_cvref_t<tuple_element_t<1, typename iterator_traits<_Iter>::value_type>>;
 #else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
-    typename iterator_traits<_Iter>::value_type::second_type;
+    _Remove_cvref_t<typename iterator_traits<_Iter>::value_type::second_type>;
 #endif // ^^^ !_HAS_CXX23 ^^^
 
 template <class _Iter>
-using _Guide_pair_t =
-#if _HAS_CXX23
-    pair<add_const_t<tuple_element_t<0, typename iterator_traits<_Iter>::value_type>>,
-        tuple_element_t<1, typename iterator_traits<_Iter>::value_type>>;
-#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
-    pair<add_const_t<typename iterator_traits<_Iter>::value_type::first_type>,
-        typename iterator_traits<_Iter>::value_type::second_type>;
-#endif // ^^^ !_HAS_CXX23 ^^^
+using _Guide_pair_t = pair<const _Guide_key_t<_Iter>, _Guide_val_t<_Iter>>;
 
 _EXPORT_STD template <class _Ty>
 struct _NO_SPECIALIZATIONS_CITING("N5014 [execpol.type]/3") is_execution_policy : false_type {};
diff --git a/tests/std/tests/P0429R9_flat_map/test.cpp b/tests/std/tests/P0429R9_flat_map/test.cpp
index ca4a2989ef7..60d81c88af1 100644
--- a/tests/std/tests/P0429R9_flat_map/test.cpp
+++ b/tests/std/tests/P0429R9_flat_map/test.cpp
@@ -155,14 +155,11 @@ class MyAllocator {
 
 template <class T, class U>
 struct almost_pair {
-    using first_type  = T;
-    using second_type = U;
+    T first_; // to test LWG-4223, this member name is not `first` to avoid accidental relying
+    U second_; // to test LWG-4223, this member name is not `second` to avoid accidental relying
 
-    T first;
-    U second;
-
-    constexpr operator pair<T, U>() const {
-        return {first, second};
+    constexpr operator pair<remove_cvref_t<T>, remove_cvref_t<U>>() const {
+        return {first_, second_};
     }
 };
 
@@ -502,6 +499,33 @@ void test_construction() {
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
             assert(fmmap == fmmap1);
         }
+
+        almost_pair<int, const int> alter_pairs[]{
+            {value_types[0].first_, value_types[0].second_},
+            {value_types[1].first_, value_types[1].second_},
+            {value_types[2].first_, value_types[2].second_},
+            {value_types[3].first_, value_types[3].second_},
+            {value_types[4].first_, value_types[4].second_},
+            {value_types[5].first_, value_types[5].second_},
+        };
+
+        // Test LWG-4223
+        {
+            flat_map fmap{ranges::begin(alter_pairs), ranges::end(alter_pairs)};
+            flat_map fmap1{ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{ranges::begin(alter_pairs), ranges::end(alter_pairs)};
+            flat_multimap fmmap1{ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         // Test flat_map(iter, iter, const key_comp&, const alloc&)
@@ -531,6 +555,41 @@ void test_construction() {
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
             assert(fmmap == fmmap1);
         }
+
+        almost_pair<int, const int&> alter_pairs[]{
+            {value_types[0].first_, value_types[0].second_},
+            {value_types[1].first_, value_types[1].second_},
+            {value_types[2].first_, value_types[2].second_},
+            {value_types[3].first_, value_types[3].second_},
+            {value_types[4].first_, value_types[4].second_},
+            {value_types[5].first_, value_types[5].second_},
+        };
+
+        // Test LWG-4223
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map_my_allocator fmap{ranges::begin(alter_pairs), ranges::end(alter_pairs), MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map_my_allocator fmap1{
+                ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap_my_allocator fmmap{ranges::begin(alter_pairs), ranges::end(alter_pairs), MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap_my_allocator fmmap1{
+                ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         // Test flat_map(from_range_t, _Rng &&, const key_compare&)
@@ -553,6 +612,33 @@ void test_construction() {
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
             assert(fmmap == fmmap1);
         }
+
+        almost_pair<int, const int&&> alter_pairs[]{
+            {value_types[0].first_, move(value_types[0].second_)},
+            {value_types[1].first_, move(value_types[1].second_)},
+            {value_types[2].first_, move(value_types[2].second_)},
+            {value_types[3].first_, move(value_types[3].second_)},
+            {value_types[4].first_, move(value_types[4].second_)},
+            {value_types[5].first_, move(value_types[5].second_)},
+        };
+
+        // Test LWG-4223
+        {
+            flat_map fmap{from_range, alter_pairs};
+            flat_map fmap1{from_range, alter_pairs, less<int>{}};
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            flat_multimap fmmap{from_range, alter_pairs};
+            flat_multimap fmmap1{from_range, alter_pairs, less<int>{}};
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         // Test flat_map(from_range_t, _Rng &&, const key_compare&, const alloc&)
@@ -582,6 +668,39 @@ void test_construction() {
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
             assert(fmmap == fmmap1);
         }
+
+        almost_pair<const int&&, int> alter_pairs[]{
+            {move(value_types[0].first_), value_types[0].second_},
+            {move(value_types[1].first_), value_types[1].second_},
+            {move(value_types[2].first_), value_types[2].second_},
+            {move(value_types[3].first_), value_types[3].second_},
+            {move(value_types[4].first_), value_types[4].second_},
+            {move(value_types[5].first_), value_types[5].second_},
+        };
+
+        // Test LWG-4223
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_map fmap{from_range, alter_pairs, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_map fmap1{from_range, alter_pairs, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
+            assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
+            assert(fmap == fmap1);
+        }
+        {
+            MyAllocatorCounter allocation_counter;
+            flat_multimap fmmap{from_range, alter_pairs, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            flat_multimap fmmap1{from_range, alter_pairs, less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+
+            assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
+            assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
+            assert(fmmap == fmmap1);
+        }
     }
     {
         // Test flat_map(_Sorted_t, iter, iter, comp = key_comp())
@@ -594,6 +713,17 @@ void test_construction() {
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
             assert(fmap == fmap1);
+
+            almost_pair<const int&&, int&> alter_pairs[]{
+                {move(value_types[0].first_), value_types[0].second_},
+                {move(value_types[1].first_), value_types[1].second_},
+                {move(value_types[2].first_), value_types[2].second_},
+                {move(value_types[3].first_), value_types[3].second_},
+                {move(value_types[4].first_), value_types[4].second_},
+            };
+            // Test LWG-4223
+            flat_map fmap2{sorted_unique, ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}};
+            assert(fmap2 == fmap);
         }
         {
             almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
@@ -604,6 +734,18 @@ void test_construction() {
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
             assert(fmmap == fmmap1);
+
+            almost_pair<const int&&, int&&> alter_pairs[]{
+                {move(value_types[0].first_), move(value_types[0].second_)},
+                {move(value_types[1].first_), move(value_types[1].second_)},
+                {move(value_types[2].first_), move(value_types[2].second_)},
+                {move(value_types[3].first_), move(value_types[3].second_)},
+                {move(value_types[4].first_), move(value_types[4].second_)},
+                {move(value_types[5].first_), move(value_types[5].second_)},
+            };
+            // Test LWG-4223
+            flat_multimap fmmap2{sorted_equivalent, ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}};
+            assert(fmmap2 == fmmap);
         }
     }
     {
@@ -623,6 +765,19 @@ void test_construction() {
             assert(check_key_content(fmap, {0, 1, 2, 3, 4}));
             assert(check_value_content(fmap, {44, 2324, 635462, 433, 5}));
             assert(fmap == fmap1);
+
+            almost_pair<int&&, int&> alter_pairs[]{
+                {move(value_types[0].first_), value_types[0].second_},
+                {move(value_types[1].first_), value_types[1].second_},
+                {move(value_types[2].first_), value_types[2].second_},
+                {move(value_types[3].first_), value_types[3].second_},
+                {move(value_types[4].first_), value_types[4].second_},
+            };
+            // Test LWG-4223
+            flat_map_my_allocator fmap2{
+                sorted_unique, ranges::begin(alter_pairs), ranges::end(alter_pairs), less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            assert(fmap == fmap2);
         }
         {
             almost_pair<int, int> value_types[]{{0, 44}, {1, 2324}, {2, 635462}, {2, 7}, {3, 433}, {4, 5}};
@@ -638,6 +793,20 @@ void test_construction() {
             assert(check_key_content(fmmap, {0, 1, 2, 2, 3, 4}));
             assert(check_value_content(fmmap, {44, 2324, 635462, 7, 433, 5}));
             assert(fmmap == fmmap1);
+
+            almost_pair<int&&, int&&> alter_pairs[]{
+                {move(value_types[0].first_), move(value_types[0].second_)},
+                {move(value_types[1].first_), move(value_types[1].second_)},
+                {move(value_types[2].first_), move(value_types[2].second_)},
+                {move(value_types[3].first_), move(value_types[3].second_)},
+                {move(value_types[4].first_), move(value_types[4].second_)},
+                {move(value_types[5].first_), move(value_types[5].second_)},
+            };
+            // Test LWG-4223
+            flat_multimap_my_allocator fmmap2{sorted_equivalent, ranges::begin(alter_pairs), ranges::end(alter_pairs),
+                less<int>{}, MyAllocator<int>{}};
+            assert(allocation_counter.check_then_reset());
+            assert(fmmap == fmmap2);
         }
     }
     {
diff --git a/tests/std/tests/P0433R2_deduction_guides/test.cpp b/tests/std/tests/P0433R2_deduction_guides/test.cpp
index 7b9cf044006..7d2ff24dc79 100644
--- a/tests/std/tests/P0433R2_deduction_guides/test.cpp
+++ b/tests/std/tests/P0433R2_deduction_guides/test.cpp
@@ -637,6 +637,22 @@ void test_map_or_multimap() {
     static_assert(is_same_v<decltype(m12), M<long, char, MyGreater, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(m13), M<long, char, less<long>, MyAlloc<CPurr>>>);
 
+    using PairIter = pair<int, float>*;
+    static_assert(is_same_v<decltype(M{PairIter{}, PairIter{}}), M<int, float>>);
+
+    using PairIter2 = pair<const int, double>*;
+    static_assert(is_same_v<decltype(M{PairIter2{}, PairIter2{}}), M<int, double>>);
+
+    // Verify fixes from LWG-4223
+    using PairIter3 = pair<int, const double>*;
+    static_assert(is_same_v<decltype(M{PairIter3{}, PairIter3{}}), M<int, double>>);
+
+    using PairIter4 = pair<const int&, double>*;
+    static_assert(is_same_v<decltype(M{PairIter4{}, PairIter4{}}), M<int, double>>);
+
+    using PairIter5 = pair<int&&, const double&>*;
+    static_assert(is_same_v<decltype(M{PairIter5{}, PairIter5{}}), M<int, double>>);
+
 #if _HAS_CXX23
     M m14(from_range, first);
     M m15(from_range, first, gt);
@@ -648,19 +664,43 @@ void test_map_or_multimap() {
     static_assert(is_same_v<decltype(m16), M<long, char, MyGreater, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(m17), M<long, char, less<long>, MyAlloc<CPurr>>>);
 
-    { // Verify changes from P2165R4
-        using TupleIter = tuple<int, double>*;
-        static_assert(is_same_v<decltype(M{TupleIter{}, TupleIter{}}), M<int, double>>);
+    // Verify fixes from LWG-4223
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<pair<long, const char>*>{}}), M<long, char>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<const pair<long&, const char&&>*>{}, gt}),
+        M<long, char, MyGreater>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<pair<const long&&, char&>*>{}, gt, myal}),
+        M<long, char, MyGreater, MyAlloc<CPurr>>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<tuple<long, const char>*>{}}), M<long, char>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<const tuple<long&, const char&&>*>{}, gt}),
+        M<long, char, MyGreater>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<tuple<const long&&, char&>*>{}, gt, myal}),
+        M<long, char, MyGreater, MyAlloc<CPurr>>>);
 
-        using PairIter = pair<int, float>*;
-        static_assert(is_same_v<decltype(M{PairIter{}, PairIter{}}), M<int, float>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<const array<long, 2>*>{}}), M<long, long>>);
+    static_assert(is_same_v<decltype(M{from_range, ranges::subrange<ranges::subrange<char*, const char*>*>{}, gt}),
+        M<char*, const char*, MyGreater>>);
 
-        using ArrayIter = array<int, 2>*;
-        static_assert(is_same_v<decltype(M{ArrayIter{}, ArrayIter{}}), M<int, int>>);
+    // Verify changes from P2165R4 as fixed by LWG-4223
+    using TupleIter = tuple<int, double>*;
+    static_assert(is_same_v<decltype(M{TupleIter{}, TupleIter{}}), M<int, double>>);
 
-        using SubrangeIter = ranges::subrange<int*, int*>*;
-        static_assert(is_same_v<decltype(M{SubrangeIter{}, SubrangeIter{}}), M<int*, int*>>);
-    }
+    using TupleIter2 = tuple<const int, double>*;
+    static_assert(is_same_v<decltype(M{TupleIter2{}, TupleIter2{}}), M<int, double>>);
+
+    using TupleIter3 = tuple<int, const double>*;
+    static_assert(is_same_v<decltype(M{TupleIter3{}, TupleIter3{}}), M<int, double>>);
+
+    using TupleIter4 = tuple<const int&, double>*;
+    static_assert(is_same_v<decltype(M{TupleIter4{}, TupleIter4{}}), M<int, double>>);
+
+    using TupleIter5 = tuple<int&&, const double&>*;
+    static_assert(is_same_v<decltype(M{TupleIter5{}, TupleIter5{}}), M<int, double>>);
+
+    using ArrayIter = array<int, 2>*;
+    static_assert(is_same_v<decltype(M{ArrayIter{}, ArrayIter{}}), M<int, int>>);
+
+    using SubrangeIter = ranges::subrange<int*, int*>*;
+    static_assert(is_same_v<decltype(M{SubrangeIter{}, SubrangeIter{}}), M<int*, int*>>);
 #endif // _HAS_CXX23
 }
 
@@ -755,6 +795,16 @@ void test_unordered_map_or_unordered_multimap() {
     static_assert(is_same_v<decltype(um24), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(um25), UM<long, char, MyHash, equal_to<long>, MyAlloc<CPurr>>>);
 
+    // Verify fixes from LWG-4223
+    using PairIter1 = pair<int, const double>*;
+    static_assert(is_same_v<decltype(UM{PairIter1{}, PairIter1{}}), UM<int, double>>);
+
+    using PairIter2 = pair<const long&, char>*;
+    static_assert(is_same_v<decltype(UM{PairIter2{}, PairIter2{}, 42, hf}), UM<long, char, MyHash>>);
+
+    using PairIter3 = pair<long&&, const char&>*;
+    static_assert(is_same_v<decltype(UM{PairIter3{}, PairIter3{}, 42, hf, eq}), UM<long, char, MyHash, MyEqual>>);
+
 #if _HAS_CXX23
     UM um26(from_range, first);
     UM um27(from_range, first, 7);
@@ -773,6 +823,28 @@ void test_unordered_map_or_unordered_multimap() {
     static_assert(is_same_v<decltype(um31), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(um32), UM<long, char, hash<long>, equal_to<long>, MyAlloc<CPurr>>>);
     static_assert(is_same_v<decltype(um33), UM<long, char, MyHash, equal_to<long>, MyAlloc<CPurr>>>);
+
+    // Verify fixes from LWG-4223
+    using TupleIter1 = tuple<int, const double>*;
+    static_assert(is_same_v<decltype(UM{TupleIter1{}, TupleIter1{}}), UM<int, double>>);
+    static_assert(is_same_v<decltype(UM{from_range, ranges::subrange<TupleIter1>{}}), UM<int, double>>);
+
+    using TupleIter2 = tuple<const long&, char>*;
+    static_assert(is_same_v<decltype(UM{TupleIter2{}, TupleIter2{}, 42, hf}), UM<long, char, MyHash>>);
+    static_assert(is_same_v<decltype(UM{from_range, ranges::subrange<TupleIter2>{}, 42, hf}), UM<long, char, MyHash>>);
+
+    using TupleIter3 = tuple<long&&, const char&>*;
+    static_assert(is_same_v<decltype(UM{TupleIter3{}, TupleIter3{}, 42, hf, eq}), UM<long, char, MyHash, MyEqual>>);
+    static_assert(is_same_v<decltype(UM{from_range, ranges::subrange<TupleIter3>{}, 42, hf, eq}),
+        UM<long, char, MyHash, MyEqual>>);
+
+    using ArrayIter = const array<unsigned int, 2>*;
+    static_assert(is_same_v<decltype(UM{ArrayIter{}, ArrayIter{}}), UM<unsigned int, unsigned int>>);
+    static_assert(is_same_v<decltype(UM{from_range, ranges::subrange<ArrayIter>{}}), UM<unsigned int, unsigned int>>);
+
+    using SubrangeIter = ranges::subrange<const char*, char*>*;
+    static_assert(is_same_v<decltype(UM{SubrangeIter{}, SubrangeIter{}}), UM<const char*, char*>>);
+    static_assert(is_same_v<decltype(UM{from_range, ranges::subrange<SubrangeIter>{}}), UM<const char*, char*>>);
 #endif // _HAS_CXX23
 }