From 7ac838857da15c5607a762770bcc653106479e99 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 20 Mar 2024 00:02:04 +0200
Subject: [PATCH 01/45] Fix `atomic_ref<16 bytes>::is_always_lock_free` (#4478)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/atomic                              | 15 ++++++----
 tests/std/tests/P0019R8_atomic_ref/env.lst  |  3 ++
 tests/std/tests/P0019R8_atomic_ref/test.cpp | 32 +++++++++++++++++++++
 3 files changed, 45 insertions(+), 5 deletions(-)

diff --git a/stl/inc/atomic b/stl/inc/atomic
index d96288e0131..18d1b3de576 100644
--- a/stl/inc/atomic
+++ b/stl/inc/atomic
@@ -1656,7 +1656,7 @@ _INLINE_VAR constexpr bool _Is_always_lock_free = _TypeSize <= 2 * sizeof(void*)
 #else // ^^^ _ATOMIC_HAS_DCAS / !_ATOMIC_HAS_DCAS vvv
 template <size_t _TypeSize>
 _INLINE_VAR constexpr bool _Is_always_lock_free = _TypeSize <= sizeof(void*);
-#endif // _ATOMIC_HAS_DCAS
+#endif // ^^^ !_ATOMIC_HAS_DCAS ^^^
 #endif // ^^^ break ABI ^^^
 
 template <class _Ty, bool _Is_lock_free = _Is_always_lock_free<sizeof(_Ty)>>
@@ -2179,7 +2179,7 @@ public:
         return sizeof(_Ty) <= 2 * sizeof(void*);
 #else // ^^^ _ATOMIC_HAS_DCAS / !_ATOMIC_HAS_DCAS vvv
         return sizeof(_Ty) <= sizeof(void*) || (sizeof(_Ty) <= 2 * sizeof(void*) && __std_atomic_has_cmpxchg16b());
-#endif // _ATOMIC_HAS_DCAS
+#endif // ^^^ !_ATOMIC_HAS_DCAS ^^^
     }
 #endif // ^^^ break ABI ^^^
 
@@ -2343,11 +2343,16 @@ public:
 
     atomic_ref& operator=(const atomic_ref&) = delete;
 
-    static constexpr bool is_always_lock_free = _Is_always_lock_free<sizeof(_Ty)>;
-
     static constexpr bool _Is_potentially_lock_free =
         sizeof(_Ty) <= 2 * sizeof(void*) && (sizeof(_Ty) & (sizeof(_Ty) - 1)) == 0;
 
+    static constexpr bool is_always_lock_free =
+#if _ATOMIC_HAS_DCAS
+        _Is_potentially_lock_free;
+#else // ^^^ _ATOMIC_HAS_DCAS / !_ATOMIC_HAS_DCAS vvv
+        _Is_potentially_lock_free && sizeof(_Ty) <= sizeof(void*);
+#endif // ^^^ !_ATOMIC_HAS_DCAS ^^^
+
     static constexpr size_t required_alignment = _Is_potentially_lock_free ? sizeof(_Ty) : alignof(_Ty);
 
     _NODISCARD bool is_lock_free() const noexcept {
@@ -2359,7 +2364,7 @@ public:
         } else {
             return __std_atomic_has_cmpxchg16b() != 0;
         }
-#endif // _ATOMIC_HAS_DCAS
+#endif // ^^^ !_ATOMIC_HAS_DCAS ^^^
     }
 
     void store(const _Ty _Value) const noexcept {
diff --git a/tests/std/tests/P0019R8_atomic_ref/env.lst b/tests/std/tests/P0019R8_atomic_ref/env.lst
index 351a8293d9d..b3f3ea48644 100644
--- a/tests/std/tests/P0019R8_atomic_ref/env.lst
+++ b/tests/std/tests/P0019R8_atomic_ref/env.lst
@@ -2,3 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 RUNALL_INCLUDE ..\usual_20_matrix.lst
+RUNALL_CROSSLIST
+*	PM_CL=""
+*	PM_CL="/D_STD_ATOMIC_ALWAYS_USE_CMPXCHG16B=1 /DTEST_CMPXCHG16B"
diff --git a/tests/std/tests/P0019R8_atomic_ref/test.cpp b/tests/std/tests/P0019R8_atomic_ref/test.cpp
index c5ecce949ed..a687cc97da1 100644
--- a/tests/std/tests/P0019R8_atomic_ref/test.cpp
+++ b/tests/std/tests/P0019R8_atomic_ref/test.cpp
@@ -1,6 +1,12 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#if defined(TEST_CMPXCHG16B) && (defined(__clang__) || !defined(_M_X64))
+// Skip Clang because it would require the -mcx16 compiler option.
+// Skip non-x64 because _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B is always 1 for ARM64, and is forbidden to be 1 for 32-bit.
+int main() {}
+#else // ^^^ skip test / run test vvv
+
 #include <atomic>
 #include <cassert>
 #include <cstddef>
@@ -373,6 +379,29 @@ void test_incomplete_associated_class_all() { // COMPILE-ONLY
 }
 #endif // ^^^ no workaround ^^^
 
+// GH-4472 "<atomic>: With _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B defined to 1,
+// atomic_ref<16 bytes> does not report is_lock_free and is_always_lock_free correctly"
+void test_gh_4472() {
+    struct two_pointers_t {
+        void* left;
+        void* right;
+    };
+
+    alignas(std::atomic_ref<two_pointers_t>::required_alignment) two_pointers_t two_pointers;
+
+    static_assert(std::atomic_ref<two_pointers_t>::required_alignment == sizeof(two_pointers_t));
+
+#ifdef _WIN64
+    static_assert(std::atomic_ref<two_pointers_t>::is_always_lock_free == _STD_ATOMIC_ALWAYS_USE_CMPXCHG16B);
+#else
+    static_assert(std::atomic_ref<two_pointers_t>::is_always_lock_free);
+#endif
+
+    // We expect tests to run on machines that support DCAS, which is required by Win8+.
+    std::atomic_ref<two_pointers_t> ar{two_pointers};
+    assert(ar.is_lock_free());
+}
+
 int main() {
     test_ops<false, char>();
     test_ops<false, signed char>();
@@ -425,4 +454,7 @@ int main() {
     test_ptr_ops<long*>();
 
     test_gh_1497();
+    test_gh_4472();
 }
+
+#endif // ^^^ run test ^^^

From 9a4cda8cab88b77a0bb3d6bf561d305143f42748 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 20 Mar 2024 00:12:54 +0200
Subject: [PATCH 02/45] Remove attempt on unsized find vectorization... (#4486)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/src/find_and_count.cpp | 19 -------
 stl/inc/xutility                  | 83 +++++++++------------------
 stl/src/vector_algorithms.cpp     | 93 ++++++-------------------------
 3 files changed, 43 insertions(+), 152 deletions(-)

diff --git a/benchmarks/src/find_and_count.cpp b/benchmarks/src/find_and_count.cpp
index 0b7561d4a9a..7b205aee6a0 100644
--- a/benchmarks/src/find_and_count.cpp
+++ b/benchmarks/src/find_and_count.cpp
@@ -42,31 +42,12 @@ BENCHMARK(bm<uint8_t, 8021, 3056, Op::FindUnsized>);
 BENCHMARK(bm<uint8_t, 8021, 3056, Op::Count>);
 
 BENCHMARK(bm<uint16_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint16_t, 8021, 3056, Op::FindUnsized>);
 BENCHMARK(bm<uint16_t, 8021, 3056, Op::Count>);
 
 BENCHMARK(bm<uint32_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint32_t, 8021, 3056, Op::FindUnsized>);
 BENCHMARK(bm<uint32_t, 8021, 3056, Op::Count>);
 
 BENCHMARK(bm<uint64_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint64_t, 8021, 3056, Op::FindUnsized>);
 BENCHMARK(bm<uint64_t, 8021, 3056, Op::Count>);
 
-BENCHMARK(bm<int8_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<int8_t, 8021, 3056, Op::FindUnsized>);
-BENCHMARK(bm<int8_t, 8021, 3056, Op::Count>);
-
-BENCHMARK(bm<int16_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<int16_t, 8021, 3056, Op::FindUnsized>);
-BENCHMARK(bm<int16_t, 8021, 3056, Op::Count>);
-
-BENCHMARK(bm<int32_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<int32_t, 8021, 3056, Op::FindUnsized>);
-BENCHMARK(bm<int32_t, 8021, 3056, Op::Count>);
-
-BENCHMARK(bm<int64_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<int64_t, 8021, 3056, Op::FindUnsized>);
-BENCHMARK(bm<int64_t, 8021, 3056, Op::Count>);
-
 BENCHMARK_MAIN();
diff --git a/stl/inc/xutility b/stl/inc/xutility
index c946f9379d8..260c44f211f 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -90,11 +90,6 @@ const void* __stdcall __std_find_trivial_2(const void* _First, const void* _Last
 const void* __stdcall __std_find_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
 const void* __stdcall __std_find_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
 
-const void* __stdcall __std_find_trivial_unsized_1(const void* _First, uint8_t _Val) noexcept;
-const void* __stdcall __std_find_trivial_unsized_2(const void* _First, uint16_t _Val) noexcept;
-const void* __stdcall __std_find_trivial_unsized_4(const void* _First, uint32_t _Val) noexcept;
-const void* __stdcall __std_find_trivial_unsized_8(const void* _First, uint64_t _Val) noexcept;
-
 const void* __stdcall __std_min_element_1(const void* _First, const void* _Last, bool _Signed) noexcept;
 const void* __stdcall __std_min_element_2(const void* _First, const void* _Last, bool _Signed) noexcept;
 const void* __stdcall __std_min_element_4(const void* _First, const void* _Last, bool _Signed) noexcept;
@@ -170,27 +165,6 @@ _Ty* __std_find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) n
     }
 }
 
-template <class _Ty, class _TVal>
-_Ty* __std_find_trivial_unsized(_Ty* const _First, const _TVal _Val) noexcept {
-    if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) {
-        return _STD __std_find_trivial_unsized(_First, reinterpret_cast<uintptr_t>(_Val));
-    } else if constexpr (sizeof(_Ty) == 1) {
-        return const_cast<_Ty*>(
-            static_cast<const _Ty*>(::__std_find_trivial_unsized_1(_First, static_cast<uint8_t>(_Val))));
-    } else if constexpr (sizeof(_Ty) == 2) {
-        return const_cast<_Ty*>(
-            static_cast<const _Ty*>(::__std_find_trivial_unsized_2(_First, static_cast<uint16_t>(_Val))));
-    } else if constexpr (sizeof(_Ty) == 4) {
-        return const_cast<_Ty*>(
-            static_cast<const _Ty*>(::__std_find_trivial_unsized_4(_First, static_cast<uint32_t>(_Val))));
-    } else if constexpr (sizeof(_Ty) == 8) {
-        return const_cast<_Ty*>(
-            static_cast<const _Ty*>(::__std_find_trivial_unsized_8(_First, static_cast<uint64_t>(_Val))));
-    } else {
-        static_assert(_Always_false<_Ty>, "Unexpected size");
-    }
-}
-
 template <class _Ty>
 _Ty* __std_min_element(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
@@ -5975,8 +5949,14 @@ namespace ranges {
     template <input_iterator _It, sentinel_for<_It> _Se, class _Ty, class _Pj = identity>
         requires indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty*>
     _NODISCARD constexpr _It _Find_unchecked(_It _First, const _Se _Last, const _Ty& _Val, _Pj _Proj = {}) {
-        constexpr bool _Is_sized = sized_sentinel_for<_Se, _It>;
-        if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty> && _Sized_or_unreachable_sentinel_for<_Se, _It>
+        // TRANSITION, DevCom-1614562: not trying wmemchr
+        // Only single-byte elements are suitable for unsized optimization
+        constexpr bool _Single_byte_elements = sizeof(_Iter_value_t<_It>) == 1;
+        constexpr bool _Is_sized             = sized_sentinel_for<_Se, _It>;
+
+        if constexpr (_Vector_alg_in_find_is_safe<_It, _Ty>
+                      && (_Single_byte_elements ? _Is_sized || same_as<_Se, unreachable_sentinel_t>
+                                                : _Is_sized && _USE_STD_VECTOR_ALGORITHMS)
                       && same_as<_Pj, identity>) {
             if (!_STD is_constant_evaluated()) {
                 if (!_STD _Could_compare_equal_to_value_type<_It>(_Val)) {
@@ -5988,27 +5968,19 @@ namespace ranges {
                     }
                 }
 
-                using _Ptr_t = remove_reference_t<_Iter_ref_t<_It>>*;
-#if _USE_STD_VECTOR_ALGORITHMS
+                using _Ptr_t          = remove_reference_t<_Iter_ref_t<_It>>*;
                 const auto _First_ptr = _STD _To_address(_First);
 
                 _Ptr_t _Result;
-
+#if _USE_STD_VECTOR_ALGORITHMS
                 if constexpr (_Is_sized) {
+                    // When _Is_sized && _Single_byte_elements, prefer this over memchr() for performance
                     const auto _Last_ptr = _First_ptr + (_Last - _First);
-
-                    _Result = _STD __std_find_trivial(_First_ptr, _Last_ptr, _Val);
-                } else {
-                    _Result = _STD __std_find_trivial_unsized(_First_ptr, _Val);
-                }
-
-                if constexpr (is_pointer_v<_It>) {
-                    return _Result;
-                } else {
-                    return _RANGES next(_STD move(_First), _Result - _First_ptr);
-                }
-#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
-                if constexpr (sizeof(_Iter_value_t<_It>) == 1) {
+                    _Result              = _STD __std_find_trivial(_First_ptr, _Last_ptr, _Val);
+                } else
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
+                {
+                    _STL_INTERNAL_STATIC_ASSERT(_Single_byte_elements);
                     size_t _Count;
                     if constexpr (_Is_sized) {
                         _Count = static_cast<size_t>(_Last - _First);
@@ -6016,21 +5988,20 @@ namespace ranges {
                         _Count = SIZE_MAX;
                     }
 
-                    const auto _First_ptr = _STD to_address(_First);
-                    const auto _Result =
-                        static_cast<_Ptr_t>(_CSTD memchr(_First_ptr, static_cast<unsigned char>(_Val), _Count));
-                    if (_Result) {
-                        if constexpr (is_pointer_v<_It>) {
-                            return _Result;
-                        } else {
-                            return _RANGES next(_STD move(_First), _Result - _First_ptr);
+                    _Result = static_cast<_Ptr_t>(_CSTD memchr(_First_ptr, static_cast<unsigned char>(_Val), _Count));
+
+                    if constexpr (_Is_sized) {
+                        if (_Result == nullptr) {
+                            return _RANGES next(_STD move(_First), _Last);
                         }
-                    } else {
-                        return _RANGES next(_STD move(_First), _Last);
                     }
                 }
-                // TRANSITION, DevCom-1614562: not trying wmemchr
-#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
+
+                if constexpr (is_pointer_v<_It>) {
+                    return _Result;
+                } else {
+                    return _RANGES next(_STD move(_First), _Result - _First_ptr);
+                }
             }
         }
 
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index bf9de5a308d..d1e2b654e4a 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -1837,79 +1837,9 @@ namespace {
 #endif // !_M_ARM64EC
     };
 
-    // The below functions have exactly the same signature as the extern "C" functions, up to calling convention.
-    // This makes sure the template specialization is fused with the extern "C" function.
-    // In optimized builds it avoids an extra call, as this function is too large to inline.
-
-    template <class _Traits, class _Ty>
-    const void* __stdcall __std_find_trivial_unsized_impl(const void* _First, const _Ty _Val) noexcept {
-#ifndef _M_ARM64EC
-        if ((reinterpret_cast<uintptr_t>(_First) & (sizeof(_Ty) - 1)) != 0) {
-            // _First isn't aligned to sizeof(_Ty), so we need to use the scalar fallback below.
-            // This can happen with 8-byte elements on x86's 4-aligned stack. It can also happen with packed structs.
-        } else if (_Use_avx2()) {
-            _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
-
-            // We read by vector-sized pieces, and we align pointers to vector-sized boundary.
-            // From start partial piece we mask out matches that don't belong to the range.
-            // This makes sure we never cross page boundary, thus we read 'as if' sequentially.
-            constexpr size_t _Vector_pad_mask = 0x1F;
-            constexpr unsigned int _Full_mask = 0xFFFF'FFFF;
-
-            const __m256i _Comparand  = _Traits::_Set_avx(_Val);
-            const intptr_t _Pad_start = reinterpret_cast<intptr_t>(_First) & _Vector_pad_mask;
-            const unsigned int _Mask  = _Full_mask << _Pad_start;
-            _Advance_bytes(_First, -_Pad_start);
-
-            __m256i _Data       = _mm256_load_si256(static_cast<const __m256i*>(_First));
-            unsigned int _Bingo = static_cast<unsigned int>(_mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand)));
-
-            _Bingo &= _Mask;
-
-            for (;;) {
-                if (_Bingo != 0) {
-                    unsigned long _Offset = _tzcnt_u32(_Bingo);
-                    _Advance_bytes(_First, _Offset);
-                    return _First;
-                }
-
-                _Advance_bytes(_First, 32);
-
-                _Data  = _mm256_load_si256(static_cast<const __m256i*>(_First));
-                _Bingo = static_cast<unsigned int>(_mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand)));
-            }
-        } else if (_Traits::_Sse_available()) {
-            // We read by vector-sized pieces, and we align pointers to vector-sized boundary.
-            // From start partial piece we mask out matches that don't belong to the range.
-            // This makes sure we never cross page boundary, thus we read 'as if' sequentially.
-            constexpr size_t _Vector_pad_mask = 0xF;
-            constexpr unsigned int _Full_mask = 0xFFFF;
-
-            const __m128i _Comparand  = _Traits::_Set_sse(_Val);
-            const intptr_t _Pad_start = reinterpret_cast<intptr_t>(_First) & _Vector_pad_mask;
-            const unsigned int _Mask  = _Full_mask << _Pad_start;
-            _Advance_bytes(_First, -_Pad_start);
-
-            __m128i _Data       = _mm_load_si128(static_cast<const __m128i*>(_First));
-            unsigned int _Bingo = static_cast<unsigned int>(_mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand)));
-
-            _Bingo &= _Mask;
-
-            for (;;) {
-                if (_Bingo != 0) {
-                    unsigned long _Offset;
-                    _BitScanForward(&_Offset, _Bingo); // lgtm [cpp/conditionallyuninitializedvariable]
-                    _Advance_bytes(_First, _Offset);
-                    return _First;
-                }
-
-                _Advance_bytes(_First, 16);
-
-                _Data  = _mm_load_si128(static_cast<const __m128i*>(_First));
-                _Bingo = static_cast<unsigned int>(_mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand)));
-            }
-        }
-#endif // !_M_ARM64EC
+    // TRANSITION, ABI: used only in functions preserved for binary compatibility
+    template <class _Ty>
+    const void* __std_find_trivial_unsized_impl(const void* const _First, const _Ty _Val) noexcept {
         auto _Ptr = static_cast<const _Ty*>(_First);
         while (*_Ptr != _Val) {
             ++_Ptr;
@@ -1917,6 +1847,10 @@ namespace {
         return _Ptr;
     }
 
+    // The below functions have exactly the same signature as the extern "C" functions, up to calling convention.
+    // This makes sure the template specialization can be fused with the extern "C" function.
+    // In optimized builds it avoids an extra call, as these functions are too large to inline.
+
     template <class _Traits, class _Ty>
     const void* __stdcall __std_find_trivial_impl(const void* _First, const void* _Last, _Ty _Val) noexcept {
 #ifndef _M_ARM64EC
@@ -2079,20 +2013,25 @@ namespace {
 
 extern "C" {
 
+// TRANSITION, ABI: preserved for binary compatibility
 const void* __stdcall __std_find_trivial_unsized_1(const void* const _First, const uint8_t _Val) noexcept {
-    return __std_find_trivial_unsized_impl<_Find_traits_1>(_First, _Val);
+    return memchr(_First, _Val, SIZE_MAX);
 }
 
+// TRANSITION, ABI: preserved for binary compatibility
 const void* __stdcall __std_find_trivial_unsized_2(const void* const _First, const uint16_t _Val) noexcept {
-    return __std_find_trivial_unsized_impl<_Find_traits_2>(_First, _Val);
+    // TRANSITION, DevCom-1614562: not trying wmemchr
+    return __std_find_trivial_unsized_impl(_First, _Val);
 }
 
+// TRANSITION, ABI: preserved for binary compatibility
 const void* __stdcall __std_find_trivial_unsized_4(const void* const _First, const uint32_t _Val) noexcept {
-    return __std_find_trivial_unsized_impl<_Find_traits_4>(_First, _Val);
+    return __std_find_trivial_unsized_impl(_First, _Val);
 }
 
+// TRANSITION, ABI: preserved for binary compatibility
 const void* __stdcall __std_find_trivial_unsized_8(const void* const _First, const uint64_t _Val) noexcept {
-    return __std_find_trivial_unsized_impl<_Find_traits_8>(_First, _Val);
+    return __std_find_trivial_unsized_impl(_First, _Val);
 }
 
 const void* __stdcall __std_find_trivial_1(

From 2175098dee5c987a0c7ab8d047804d770eacfbbb Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Tue, 19 Mar 2024 15:20:56 -0700
Subject: [PATCH 03/45] Standard Library Modules: Fix warning C4365
 (signed/unsigned mismatch) with `/ZI` (#4487)

---
 stl/inc/yvals.h | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/stl/inc/yvals.h b/stl/inc/yvals.h
index 9428b35aaeb..d2201390f57 100644
--- a/stl/inc/yvals.h
+++ b/stl/inc/yvals.h
@@ -172,8 +172,10 @@ _STL_DISABLE_CLANG_WARNINGS
 #ifndef _STL_CRT_SECURE_INVALID_PARAMETER
 #ifdef _STL_CALL_ABORT_INSTEAD_OF_INVALID_PARAMETER
 #define _STL_CRT_SECURE_INVALID_PARAMETER(expr) _CSTD abort()
-#elif defined(_DEBUG) // avoid emitting unused long strings for function names; see GH-1956
-#define _STL_CRT_SECURE_INVALID_PARAMETER(expr) ::_invalid_parameter(_CRT_WIDE(#expr), L"", __FILEW__, __LINE__, 0)
+#elif defined(_DEBUG) // Avoid emitting unused long strings for function names; see GH-1956.
+// static_cast<unsigned int>(__LINE__) avoids warning C4365 (signed/unsigned mismatch) with the /ZI compiler option.
+#define _STL_CRT_SECURE_INVALID_PARAMETER(expr) \
+    ::_invalid_parameter(_CRT_WIDE(#expr), L"", __FILEW__, static_cast<unsigned int>(__LINE__), 0)
 #else // ^^^ defined(_DEBUG) / !defined(_DEBUG) vvv
 #define _STL_CRT_SECURE_INVALID_PARAMETER(expr) _CRT_SECURE_INVALID_PARAMETER(expr)
 #endif // ^^^ !defined(_DEBUG) ^^^
@@ -465,11 +467,7 @@ class _CRTIMP2_PURE_IMPORT _EmptyLockit { // empty lock class used for bin compa
     }              \
     }
 
-#ifdef _DEBUG
-#define _RAISE(x) _invoke_watson(_CRT_WIDE(#x), __FUNCTIONW__, __FILEW__, __LINE__, 0)
-#else
 #define _RAISE(x) _invoke_watson(nullptr, nullptr, nullptr, 0, 0)
-#endif
 
 #define _RERAISE
 #define _THROW(...) (__VA_ARGS__)._Raise()

From 4787efeae109b601d0f04edf3083325b4c9fd4ed Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 20 Mar 2024 06:57:56 +0800
Subject: [PATCH 04/45] `<tuple>`, `<utility>`: Make `tuple`-related functions
 ADL-proof (#4488)

---
 stl/inc/tuple                                 |  10 +-
 stl/inc/utility                               |   3 +-
 .../tests/Dev11_0000000_tuple_cat/test.cpp    | 314 ++++++++++++------
 3 files changed, 222 insertions(+), 105 deletions(-)

diff --git a/stl/inc/tuple b/stl/inc/tuple
index f5e120cf39f..c49a9205c5f 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -1053,7 +1053,7 @@ _NODISCARD constexpr typename _Tuple_cat1<_Tuples...>::_Ret tuple_cat(_Tuples&&.
     using _Ret    = typename _Cat1::_Ret;
     using _Kx_seq = typename _Cat1::_Kx_seq;
     using _Ix_seq = typename _Cat1::_Ix_seq;
-    return _Tuple_cat<_Ret>(_Kx_seq{}, _Ix_seq{}, _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...));
+    return _STD _Tuple_cat<_Ret>(_Kx_seq{}, _Ix_seq{}, _STD forward_as_tuple(_STD forward<_Tuples>(_Tpls)...));
 }
 
 #if _HAS_CXX17
@@ -1073,9 +1073,9 @@ _EXPORT_STD template <class _Callable, _Tuple_like _Tuple>
 _EXPORT_STD template <class _Callable, class _Tuple>
 #endif // ^^^ !_HAS_CXX23 ^^^
 constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
-    noexcept(_Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
+    noexcept(_STD _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) {
-    return _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
+    return _STD _Apply_impl(_STD forward<_Callable>(_Obj), _STD forward<_Tuple>(_Tpl),
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
 }
 
@@ -1097,10 +1097,10 @@ _EXPORT_STD template <class _Ty, _Tuple_like _Tuple>
 #else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
 _EXPORT_STD template <class _Ty, class _Tuple>
 #endif // ^^^ !_HAS_CXX23 ^^^
-_NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_Make_from_tuple_impl<_Ty>(
+_NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_STD _Make_from_tuple_impl<_Ty>(
     _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) /* strengthened */ {
     // construct _Ty from the elements of _Tpl
-    return _Make_from_tuple_impl<_Ty>(
+    return _STD _Make_from_tuple_impl<_Ty>(
         _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
 }
 #endif // _HAS_CXX17
diff --git a/stl/inc/utility b/stl/inc/utility
index 3206659c1be..458091fb313 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -304,7 +304,8 @@ struct pair { // store a pair of values
 
     template <class _Tuple1, class _Tuple2, size_t... _Indices1, size_t... _Indices2>
     constexpr pair(_Tuple1& _Val1, _Tuple2& _Val2, index_sequence<_Indices1...>, index_sequence<_Indices2...>)
-        : first(_Tuple_get<_Indices1>(_STD move(_Val1))...), second(_Tuple_get<_Indices2>(_STD move(_Val2))...) {}
+        : first(_STD _Tuple_get<_Indices1>(_STD move(_Val1))...),
+          second(_STD _Tuple_get<_Indices2>(_STD move(_Val2))...) {}
 
     template <class... _Types1, class... _Types2>
     _CONSTEXPR20 pair(piecewise_construct_t, tuple<_Types1...> _Val1, tuple<_Types2...> _Val2)
diff --git a/tests/std/tests/Dev11_0000000_tuple_cat/test.cpp b/tests/std/tests/Dev11_0000000_tuple_cat/test.cpp
index 78a23775861..dec106b5eae 100644
--- a/tests/std/tests/Dev11_0000000_tuple_cat/test.cpp
+++ b/tests/std/tests/Dev11_0000000_tuple_cat/test.cpp
@@ -3,6 +3,7 @@
 
 #include <array>
 #include <cassert>
+#include <cstddef>
 #include <functional>
 #include <memory>
 #include <string>
@@ -10,6 +11,10 @@
 #include <type_traits>
 #include <utility>
 
+#if _HAS_CXX17
+#include <string_view>
+#endif // _HAS_CXX17
+
 #if _HAS_CXX20
 #include <iterator>
 #include <list>
@@ -21,8 +26,26 @@ using namespace std;
 
 #define STATIC_ASSERT(...) static_assert(__VA_ARGS__, #__VA_ARGS__)
 
+#if _HAS_CXX17
+#define CONSTEXPR17 constexpr
+#else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
+#define CONSTEXPR17 inline
+#endif // ^^^ !_HAS_CXX17 ^^^
+
+#if _HAS_CXX20
+#define CONSTEXPR20 constexpr
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+#define CONSTEXPR20 inline
+#endif // ^^^ !_HAS_CXX20 ^^^
+
+#if _HAS_CXX23
+#define CONSTEXPR23 constexpr
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+#define CONSTEXPR23 inline
+#endif // ^^^ !_HAS_CXX23 ^^^
+
 template <template <typename...> class PairOrTuple>
-void test_value_categories() {
+constexpr void test_value_categories() {
     int n1       = 10;
     const int n2 = 20;
     int n3       = 30;
@@ -56,7 +79,7 @@ void test_value_categories() {
     }
 }
 
-int main() {
+constexpr bool test() {
     {
         tuple<> x;
 
@@ -130,42 +153,6 @@ int main() {
         assert(t3 == make_tuple(static_cast<short>(11), 22, 33L, 400UL, 500U, static_cast<unsigned short>(600)));
     }
 
-    {
-        unique_ptr<int> up;
-
-        up.reset(new int(10));
-        tuple<string, unique_ptr<int>, int> a("ten", move(up), 11);
-
-        up.reset(new int(20));
-        tuple<string, int, unique_ptr<int>> b("twenty", 22, move(up));
-
-        up.reset(new int(30));
-        tuple<int, string, unique_ptr<int>> c(33, "thirty", move(up));
-
-        tuple<int, int> d(44, 55);
-
-        auto t0 = tuple_cat(move(a), move(b), move(c), d);
-
-        STATIC_ASSERT(is_same_v<decltype(t0),
-            tuple<string, unique_ptr<int>, int, string, int, unique_ptr<int>, int, string, unique_ptr<int>, int, int>>);
-
-        assert(!get<1>(a));
-        assert(!get<2>(b));
-        assert(!get<2>(c));
-
-        assert(get<0>(t0) == "ten");
-        assert(*get<1>(t0) == 10);
-        assert(get<2>(t0) == 11);
-        assert(get<3>(t0) == "twenty");
-        assert(get<4>(t0) == 22);
-        assert(*get<5>(t0) == 20);
-        assert(get<6>(t0) == 33);
-        assert(get<7>(t0) == "thirty");
-        assert(*get<8>(t0) == 30);
-        assert(get<9>(t0) == 44);
-        assert(get<10>(t0) == 55);
-    }
-
     {
         int w = 11, x = 22, y = 33, z = 44;
 
@@ -187,30 +174,6 @@ int main() {
         assert(&get<5>(t1) == &z);
     }
 
-    {
-        pair<int, int> p(11, 22);
-
-        const char* const s = "meow";
-
-        array<short, 0> zero;
-
-        array<int, 1> one = {{40}};
-
-        array<long, 2> two = {{50L, 60L}};
-
-        auto make_array = [] {
-            array<char, 3> ret = {{'x', 'y', 'z'}};
-            return ret;
-        };
-
-        const auto t = tuple_cat(p, make_pair(33U, s), zero, one, two, make_array(), make_tuple(1234LL));
-
-        STATIC_ASSERT(is_same_v<decltype(t),
-            const tuple<int, int, unsigned int, const char*, int, long, long, char, char, char, long long>>);
-
-        assert(t == make_tuple(11, 22, 33U, s, 40, 50L, 60L, 'x', 'y', 'z', 1234LL));
-    }
-
     test_value_categories<pair>();
     test_value_categories<tuple>();
 
@@ -231,29 +194,6 @@ int main() {
         }
     }
 
-#if _HAS_CXX20
-    {
-        using ranges::subrange, ranges::subrange_kind;
-
-        list<int> lst     = {10, 20, 30, 40, 50};
-        using LstIter     = list<int>::iterator;
-        using LstSubrange = subrange<LstIter>; // test unsized
-        STATIC_ASSERT(is_same_v<LstSubrange, subrange<LstIter, LstIter, subrange_kind::unsized>>);
-        LstSubrange lst_subrange(next(lst.begin()), prev(lst.end()));
-
-        vector<int> vec    = {60, 70, 80, 90, 100};
-        using VecIter      = vector<int>::iterator;
-        using VecConstIter = vector<int>::const_iterator;
-        using VecSubrange  = subrange<VecIter, VecConstIter>; // test sized, and different iterator/sentinel types
-        STATIC_ASSERT(is_same_v<VecSubrange, subrange<VecIter, VecConstIter, subrange_kind::sized>>);
-        VecSubrange vec_subrange(vec.begin() + 1, vec.cend() - 1);
-
-        auto cat7 = tuple_cat(lst_subrange, vec_subrange);
-        STATIC_ASSERT(is_same_v<decltype(cat7), tuple<LstIter, LstIter, VecIter, VecConstIter>>);
-        assert(cat7 == make_tuple(next(lst.begin()), prev(lst.end()), vec.begin() + 1, vec.cend() - 1));
-    }
-#endif // _HAS_CXX20
-
 // Also test C++17 apply() and make_from_tuple().
 #if _HAS_CXX17
     {
@@ -261,7 +201,7 @@ int main() {
             int x;
             int y;
 
-            int add(int z) const {
+            constexpr int add(int z) const {
                 return x + y + z;
             }
         };
@@ -270,22 +210,12 @@ int main() {
 
         assert(apply(&Point::add, make_tuple(&p, 3)) == 123);
 
-        assert(make_from_tuple<string>(make_tuple(static_cast<size_t>(5), 's')) == "sssss");
+        assert(make_from_tuple<string_view>(make_tuple("Hello world!", static_cast<size_t>(5))) == "Hello");
     }
 #endif // _HAS_CXX17
 
     // Also test VSO-181496 "Variadic template emits spurious warning C4100: unreferenced formal parameter".
     {
-        auto b1 = bind([] { return 256; });
-        assert(b1() == 256);
-
-        auto b2 = bind([](int i) { return i * 3; }, b1);
-        assert(b2() == 768);
-
-        const pair<int, int> p(piecewise_construct, tuple<>{}, tuple<>{});
-        assert(p.first == 0);
-        assert(p.second == 0);
-
         assert(tuple_cat() == tuple<>{});
 
 #if _HAS_CXX17
@@ -295,10 +225,161 @@ int main() {
 #endif // _HAS_CXX17
     }
 
-    // LWG-3211 std::tuple<> should be trivially constructible
-    STATIC_ASSERT(is_trivially_default_constructible_v<tuple<>>);
+    return true;
 }
 
+#ifndef _M_CEE // TRANSITION, VSO-1659496
+// Also test GH-140 "STL: We should _STD qualify _Ugly function calls to avoid ADL"
+template <class T>
+struct holder {
+    T t;
+};
+
+struct incomplete;
+using validator = holder<incomplete>*;
+
+constexpr bool test_adl_proof() {
+    // Function calls are intentionally qualified.
+
+    auto concatenated = std::tuple_cat(std::make_tuple(validator{}), std::make_tuple(42));
+    STATIC_ASSERT(is_same_v<decltype(concatenated), tuple<validator, int>>);
+
+    assert(std::get<0>(concatenated) == nullptr);
+    assert(std::get<1>(concatenated) == 42);
+
+#if _HAS_CXX17
+    assert(std::make_from_tuple<validator>(std::make_tuple(validator{})) == nullptr);
+    assert(std::apply([](auto) { return 42; }, std::make_tuple(validator{})) == 42);
+#endif // _HAS_CXX17
+
+    return true;
+}
+#endif // ^^^ no workaround ^^^
+
+CONSTEXPR17 bool test_using_lambda() {
+    pair<int, int> p(11, 22);
+
+    const char* const s = "meow";
+
+    array<short, 0> zero;
+
+    array<int, 1> one = {{40}};
+
+    array<long, 2> two = {{50L, 60L}};
+
+    auto make_array = [] {
+        array<char, 3> ret = {{'x', 'y', 'z'}};
+        return ret;
+    };
+
+    const auto t = tuple_cat(p, make_pair(33U, s), zero, one, two, make_array(), make_tuple(1234LL));
+
+    STATIC_ASSERT(is_same_v<decltype(t),
+        const tuple<int, int, unsigned int, const char*, int, long, long, char, char, char, long long>>);
+
+    assert(t == make_tuple(11, 22, 33U, s, 40, 50L, 60L, 'x', 'y', 'z', 1234LL));
+
+    return true;
+}
+
+CONSTEXPR20 bool test_bind_and_piecewise_construction() {
+    // Also test VSO-181496 "Variadic template emits spurious warning C4100: unreferenced formal parameter".
+    auto b1 = bind([] { return 256; });
+    assert(b1() == 256);
+
+    auto b2 = bind([](int i) { return i * 3; }, b1);
+    assert(b2() == 768);
+
+    const pair<int, int> p(piecewise_construct, tuple<>{}, tuple<>{});
+    assert(p.first == 0);
+    assert(p.second == 0);
+
+#ifndef _M_CEE // TRANSITION, VSO-1659496
+    const pair<validator, int> p2(piecewise_construct, tuple<validator>{}, tuple<int>{});
+    assert(p2.first == nullptr);
+    assert(p2.second == 0);
+#endif // ^^^ no workaround ^^^
+
+    return true;
+}
+
+#if _HAS_CXX17
+// Also test C++17 make_from_tuple() and C++20 constexpr string.
+CONSTEXPR20 bool test_make_from_tuple_and_string() {
+    assert(make_from_tuple<string>(tuple<>{}).empty());
+    assert(make_from_tuple<string>(make_tuple(static_cast<size_t>(5), 's')) == "sssss");
+
+    assert(make_from_tuple<wstring>(tuple<>{}).empty());
+    assert(make_from_tuple<wstring>(make_tuple(static_cast<size_t>(5), L's')) == L"sssss");
+
+    return true;
+}
+#endif // _HAS_CXX17
+
+CONSTEXPR23 bool test_unique_ptr_and_string() {
+    unique_ptr<int> up;
+
+    up.reset(new int(10));
+    tuple<string, unique_ptr<int>, int> a("ten", move(up), 11);
+
+    up.reset(new int(20));
+    tuple<string, int, unique_ptr<int>> b("twenty", 22, move(up));
+
+    up.reset(new int(30));
+    tuple<int, string, unique_ptr<int>> c(33, "thirty", move(up));
+
+    tuple<int, int> d(44, 55);
+
+    auto t0 = tuple_cat(move(a), move(b), move(c), d);
+
+    STATIC_ASSERT(is_same_v<decltype(t0),
+        tuple<string, unique_ptr<int>, int, string, int, unique_ptr<int>, int, string, unique_ptr<int>, int, int>>);
+
+    assert(!get<1>(a));
+    assert(!get<2>(b));
+    assert(!get<2>(c));
+
+    assert(get<0>(t0) == "ten");
+    assert(*get<1>(t0) == 10);
+    assert(get<2>(t0) == 11);
+    assert(get<3>(t0) == "twenty");
+    assert(get<4>(t0) == 22);
+    assert(*get<5>(t0) == 20);
+    assert(get<6>(t0) == 33);
+    assert(get<7>(t0) == "thirty");
+    assert(*get<8>(t0) == 30);
+    assert(get<9>(t0) == 44);
+    assert(get<10>(t0) == 55);
+
+    return true;
+}
+
+#if _HAS_CXX20
+void test_subrange_and_containers() {
+    using ranges::subrange, ranges::subrange_kind;
+
+    list<int> lst     = {10, 20, 30, 40, 50};
+    using LstIter     = list<int>::iterator;
+    using LstSubrange = subrange<LstIter>; // test unsized
+    STATIC_ASSERT(is_same_v<LstSubrange, subrange<LstIter, LstIter, subrange_kind::unsized>>);
+    LstSubrange lst_subrange(next(lst.begin()), prev(lst.end()));
+
+    vector<int> vec    = {60, 70, 80, 90, 100};
+    using VecIter      = vector<int>::iterator;
+    using VecConstIter = vector<int>::const_iterator;
+    using VecSubrange  = subrange<VecIter, VecConstIter>; // test sized, and different iterator/sentinel types
+    STATIC_ASSERT(is_same_v<VecSubrange, subrange<VecIter, VecConstIter, subrange_kind::sized>>);
+    VecSubrange vec_subrange(vec.begin() + 1, vec.cend() - 1);
+
+    auto cat7 = tuple_cat(lst_subrange, vec_subrange);
+    STATIC_ASSERT(is_same_v<decltype(cat7), tuple<LstIter, LstIter, VecIter, VecConstIter>>);
+    assert(cat7 == make_tuple(next(lst.begin()), prev(lst.end()), vec.begin() + 1, vec.cend() - 1));
+}
+#endif // _HAS_CXX20
+
+// LWG-3211 std::tuple<> should be trivially constructible
+STATIC_ASSERT(is_trivially_default_constructible_v<tuple<>>);
+
 // Also test DevDiv-1205400 "C++ compiler: static_assert in std::tuple_element prevents SFINAE".
 template <typename T, typename = void>
 struct HasTupleElement : false_type {};
@@ -318,3 +399,38 @@ struct HasTupleSize<T, void_t<typename tuple_size<T>::type>> : true_type {};
 
 STATIC_ASSERT(!HasTupleSize<int>::value);
 STATIC_ASSERT(HasTupleSize<tuple<short, long>>::value);
+
+STATIC_ASSERT(test());
+
+#ifndef _M_CEE // TRANSITION, VSO-1659496
+STATIC_ASSERT(test_adl_proof());
+#endif // ^^^ no workaround ^^^
+
+#if _HAS_CXX17
+STATIC_ASSERT(test_using_lambda());
+#endif // _HAS_CXX17
+
+#if _HAS_CXX20
+STATIC_ASSERT(test_bind_and_piecewise_construction());
+STATIC_ASSERT(test_make_from_tuple_and_string());
+#endif // _HAS_CXX20
+
+#if _HAS_CXX23
+STATIC_ASSERT(test_unique_ptr_and_string());
+#endif // _HAS_CXX23
+
+int main() {
+    test();
+#ifndef _M_CEE // TRANSITION, VSO-1659496
+    test_adl_proof();
+#endif // ^^^ no workaround ^^^
+    test_using_lambda();
+    test_bind_and_piecewise_construction();
+#if _HAS_CXX17
+    test_make_from_tuple_and_string();
+#endif // _HAS_CXX17
+#if _HAS_CXX20
+    test_subrange_and_containers();
+#endif //_HAS_CXX20
+    test_unique_ptr_and_string();
+}

From 243cffc219cb621aa2ea075f032588e61b70877a Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 20 Mar 2024 07:01:53 +0800
Subject: [PATCH 05/45] `<format>`: Make non-Standard constructors of
 `basic_format_arg::handle` and `basic_format_context` private (#4489)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/format                                | 59 ++++++++++---------
 .../test.cpp                                  | 47 +++++++++++++--
 2 files changed, 73 insertions(+), 33 deletions(-)

diff --git a/stl/inc/format b/stl/inc/format
index ee03e07a633..9e5d6cdc05f 100644
--- a/stl/inc/format
+++ b/stl/inc/format
@@ -708,9 +708,7 @@ public:
     private:
         const void* _Ptr;
         void(__cdecl* _Format)(basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx, const void*);
-        friend basic_format_arg;
 
-    public:
         template <class _Ty>
         explicit handle(_Ty& _Val) noexcept
             : _Ptr(_STD addressof(_Val)),
@@ -719,17 +717,7 @@ public:
                   using _Td = remove_const_t<_Ty>;
                   // doesn't drop const-qualifier per an unnumbered LWG issue
                   using _Tq = conditional_t<_Formattable_with<const _Ty, _Context>, const _Ty, _Ty>;
-                  if constexpr (_Formattable_with_non_const<_Tq, _Context>) {
-                      static_assert(_Formattable_with<_Tq, _Context>,
-                          "The format() member function can't be called on const formatter<T>. "
-                          "To make the formatter usable, add const to format(). "
-                          "See N4971 [format.arg]/12, [format.formattable], and [formatter.requirements].");
-                  } else {
-                      static_assert(_Formattable_with<_Tq, _Context>,
-                          "Cannot format an argument. "
-                          "To make this type formattable, provide a formatter<T> specialization. "
-                          "See N4971 [format.arg]/12, [format.formattable], and [formatter.requirements].");
-                  }
+                  _STL_INTERNAL_STATIC_ASSERT(_Formattable_with<_Tq, _Context>);
 
                   typename _Context::template formatter_type<_Td> _Formatter;
                   _Parse_ctx.advance_to(_Formatter.parse(_Parse_ctx));
@@ -737,9 +725,15 @@ public:
                       _Formatter.format(*const_cast<_Tq*>(static_cast<const _Td*>(_Ptr)), _Format_ctx));
               }) {}
 
+    public:
         void format(basic_format_parse_context<_CharType>& _Parse_ctx, _Context& _Format_ctx) const {
             _Format(_Parse_ctx, _Format_ctx, _Ptr);
         }
+
+        template <class _Ty>
+        _NODISCARD static handle _Make_from(_Ty& _Val) noexcept {
+            return handle{_Val};
+        }
     };
 
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-81774 (Clang), VSO-1956558 (EDG)
@@ -755,7 +749,7 @@ public:
     // Function template _Make_from mirrors the exposition-only single-argument constructor template of
     // basic_format_arg (N4950 [format.arg]).
     template <_Formattable_with<_Context> _Ty>
-    static basic_format_arg _Make_from(_Ty& _Val) noexcept {
+    _NODISCARD static basic_format_arg _Make_from(_Ty& _Val) noexcept {
         using _Erased_type = _Format_arg_traits<_Context>::template _Storage_type<_Ty>;
         if constexpr (is_same_v<remove_const_t<_Ty>, char> && is_same_v<_CharType, wchar_t>) {
             return basic_format_arg(static_cast<_Erased_type>(static_cast<unsigned char>(_Val)));
@@ -892,7 +886,7 @@ auto _Format_arg_traits<_Context>::_Type_eraser() {
         return static_cast<const void*>(nullptr);
     } else {
         int _Dummy{};
-        return typename basic_format_arg<_Context>::handle{_Dummy};
+        return basic_format_arg<_Context>::handle::_Make_from(_Dummy);
     }
 }
 
@@ -2051,6 +2045,8 @@ private:
         if constexpr (is_same_v<remove_const_t<remove_reference_t<_Ty>>, char> && is_same_v<_CharType, wchar_t>) {
             _Store_impl<_Erased_type>(
                 _Arg_index, _Arg_type, static_cast<_Erased_type>(static_cast<unsigned char>(_Val)));
+        } else if constexpr (is_same_v<_Erased_type, typename basic_format_arg<_Context>::handle>) {
+            _Store_impl<_Erased_type>(_Arg_index, _Arg_type, _Erased_type::_Make_from(_Val));
         }
 #if !_HAS_CXX23
         // Workaround towards N4950 [format.arg]/6.8 in C++20
@@ -2199,6 +2195,13 @@ private:
     basic_format_args<basic_format_context> _Args;
     _Lazy_locale _Loc;
 
+    constexpr basic_format_context(_Out&& _OutputIt_, const basic_format_args<basic_format_context>& _Ctx_args)
+        : _OutputIt(_STD move(_OutputIt_)), _Args(_Ctx_args) {}
+
+    constexpr basic_format_context(
+        _Out&& _OutputIt_, const basic_format_args<basic_format_context>& _Ctx_args, const _Lazy_locale& _Loc_)
+        : _OutputIt(_STD move(_OutputIt_)), _Args(_Ctx_args), _Loc(_Loc_) {}
+
 public:
     using iterator  = _Out;
     using char_type = _CharT;
@@ -2206,13 +2209,6 @@ public:
     template <class _Ty>
     using formatter_type = formatter<_Ty, _CharT>;
 
-    constexpr basic_format_context(_Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args)
-        : _OutputIt(_STD move(_OutputIt_)), _Args(_Ctx_args) {}
-
-    constexpr basic_format_context(
-        _Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args, const _Lazy_locale& _Loc_)
-        : _OutputIt(_STD move(_OutputIt_)), _Args(_Ctx_args), _Loc(_Loc_) {}
-
     _NODISCARD basic_format_arg<basic_format_context> arg(size_t _Id) const noexcept {
         return _Args.get(_Id);
     }
@@ -2232,6 +2228,15 @@ public:
     _NODISCARD _Lazy_locale _Get_lazy_locale() const {
         return _Loc;
     }
+
+    _NODISCARD static constexpr basic_format_context _Make_from(
+        _Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args) {
+        return basic_format_context{_STD move(_OutputIt_), _Ctx_args};
+    }
+    _NODISCARD static constexpr basic_format_context _Make_from(
+        _Out _OutputIt_, basic_format_args<basic_format_context> _Ctx_args, const _Lazy_locale& _Loc_) {
+        return basic_format_context{_STD move(_OutputIt_), _Ctx_args, _Loc_};
+    }
 };
 
 #if _HAS_CXX23
@@ -3540,7 +3545,7 @@ struct _Default_arg_formatter {
 
     _OutputIt operator()(basic_format_arg<_Context>::handle _Handle) && {
         basic_format_parse_context<_CharT> _Parse_ctx({});
-        basic_format_context<_OutputIt, _CharT> _Format_ctx(_STD move(_Out), _Args, _Loc);
+        auto _Format_ctx = _Context::_Make_from(_STD move(_Out), _Args, _Loc);
         _Handle.format(_Parse_ctx, _Format_ctx);
         return _Format_ctx.out();
     }
@@ -3626,11 +3631,11 @@ struct _Format_handler {
     _Context _Ctx;
 
     explicit _Format_handler(_OutputIt _Out, basic_string_view<_CharT> _Str, basic_format_args<_Context> _Format_args)
-        : _Parse_context(_Str), _Ctx(_STD move(_Out), _Format_args) {}
+        : _Parse_context(_Str), _Ctx(_Context::_Make_from(_STD move(_Out), _Format_args)) {}
 
     explicit _Format_handler(_OutputIt _Out, basic_string_view<_CharT> _Str, basic_format_args<_Context> _Format_args,
         const _Lazy_locale& _Loc)
-        : _Parse_context(_Str), _Ctx(_STD move(_Out), _Format_args, _Loc) {}
+        : _Parse_context(_Str), _Ctx(_Context::_Make_from(_STD move(_Out), _Format_args, _Loc)) {}
 
     void _On_text(const _CharT* _First, const _CharT* _Last) {
         _Ctx.advance_to(_RANGES _Copy_unchecked(_First, _Last, _Ctx.out()).out);
@@ -4107,8 +4112,8 @@ protected:
         }
 
         basic_string<_CharT> _Tmp_buf;
-        basic_format_context<back_insert_iterator<basic_string<_CharT>>, _CharT> _Tmp_ctx{
-            _STD back_inserter(_Tmp_buf), {}, _Fmt_ctx._Get_lazy_locale()};
+        auto _Tmp_ctx = basic_format_context<back_insert_iterator<basic_string<_CharT>>, _CharT>::_Make_from(
+            _STD back_inserter(_Tmp_buf), {}, _Fmt_ctx._Get_lazy_locale());
 
         _STD _Copy_unchecked(_Opening_bracket._Unchecked_begin(), _Opening_bracket._Unchecked_end(), _Tmp_ctx.out());
         [&]<size_t... _Indices>(index_sequence<_Indices...>) {
diff --git a/tests/std/tests/P0645R10_text_formatting_custom_formatting/test.cpp b/tests/std/tests/P0645R10_text_formatting_custom_formatting/test.cpp
index 5966daf3593..999ab832d81 100644
--- a/tests/std/tests/P0645R10_text_formatting_custom_formatting/test.cpp
+++ b/tests/std/tests/P0645R10_text_formatting_custom_formatting/test.cpp
@@ -233,19 +233,47 @@ void test_mixed_custom_formattable_type() {
     test_custom_equiv_with_format_mixed<const void*, charT>(STR("{}{}"), nullptr);
 }
 
+// Test that handle doesn't have public non-Standard constructors.
 template <class OutIt, class CharT>
 void test_basic_format_arg_handle_construction() {
     using handle = basic_format_arg<basic_format_context<OutIt, CharT>>::handle;
 
-    static_assert(is_constructible_v<handle, int&>);
-    static_assert(is_constructible_v<handle, const int&>);
+    static_assert(is_constructible_v<handle, handle>);
+    static_assert(is_constructible_v<handle, const handle&>);
+
+    static_assert(!is_constructible_v<handle, int&>);
+    static_assert(!is_constructible_v<handle, const int&>);
     static_assert(!is_constructible_v<handle, int>);
-    static_assert(is_constructible_v<handle, const int>);
+    static_assert(!is_constructible_v<handle, const int>);
 
-    static_assert(is_constructible_v<handle, custom_formattable_type<CharT>&>);
-    static_assert(is_constructible_v<handle, const custom_formattable_type<CharT>&>);
+    static_assert(!is_constructible_v<handle, custom_formattable_type<CharT>&>);
+    static_assert(!is_constructible_v<handle, const custom_formattable_type<CharT>&>);
     static_assert(!is_constructible_v<handle, custom_formattable_type<CharT>>);
-    static_assert(is_constructible_v<handle, const custom_formattable_type<CharT>>);
+    static_assert(!is_constructible_v<handle, const custom_formattable_type<CharT>>);
+}
+
+template <class T, class... Args>
+constexpr bool is_constructible_with_trailing_empty_brace_impl = requires { T(declval<Args>()..., {}); };
+
+static_assert(is_constructible_with_trailing_empty_brace_impl<string>);
+static_assert(is_constructible_with_trailing_empty_brace_impl<pair<int, int>, int>);
+static_assert(!is_constructible_with_trailing_empty_brace_impl<pair<int, int>, int, int>);
+
+// Test that basic_format_context doesn't have public non-Standard constructors.
+template <class OutIt, class CharT>
+void test_basic_format_context_construction() {
+    using context = basic_format_context<OutIt, CharT>;
+
+    static_assert(!is_default_constructible_v<context>);
+    static_assert(is_copy_constructible_v<context> == is_copy_constructible_v<OutIt>);
+    static_assert(is_move_constructible_v<context>);
+
+    static_assert(!is_constructible_v<context, OutIt, basic_format_args<context>>);
+    static_assert(!is_constructible_v<context, OutIt, const basic_format_args<context>&>);
+
+    static_assert(!is_constructible_with_trailing_empty_brace_impl<context>);
+    static_assert(!is_constructible_with_trailing_empty_brace_impl<context, OutIt, basic_format_args<context>>);
+    static_assert(!is_constructible_with_trailing_empty_brace_impl<context, OutIt, const basic_format_args<context>&>);
 }
 
 int main() {
@@ -262,5 +290,12 @@ int main() {
     test_basic_format_arg_handle_construction<wchar_t*, wchar_t>();
     test_basic_format_arg_handle_construction<wstring::iterator, wchar_t>();
     test_basic_format_arg_handle_construction<back_insert_iterator<wstring>, wchar_t>();
+
+    test_basic_format_context_construction<char*, char>();
+    test_basic_format_context_construction<string::iterator, char>();
+    test_basic_format_context_construction<back_insert_iterator<string>, char>();
+    test_basic_format_context_construction<wchar_t*, wchar_t>();
+    test_basic_format_context_construction<wstring::iterator, wchar_t>();
+    test_basic_format_context_construction<back_insert_iterator<wstring>, wchar_t>();
     return 0;
 }

From acb1178fd28797f0d6378d21faed6eb0013372fb Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 21 Mar 2024 11:08:39 -0700
Subject: [PATCH 06/45] Mirror internal MSBuild changes again (#4494)

---
 stl/msbuild/stl_1/dirs.proj                     |  2 +-
 stl/msbuild/stl_1/md/dirs.proj                  | 10 +++++-----
 .../msvcp_1.vcxproj => msvcp_1_md_app.vcxproj}  |  0
 ...cp_1.vcxproj => msvcp_1_md_kernel32.vcxproj} |  0
 ...msvcp_1.vcxproj => msvcp_1_md_netfx.vcxproj} |  0
 ...vcp_1.vcxproj => msvcp_1_md_onecore.vcxproj} |  0
 stl/msbuild/stl_1/msvcp_1.settings.targets      |  2 +-
 stl/msbuild/stl_1/xmd/dirs.proj                 | 10 +++++-----
 .../msvcp_1.vcxproj => msvcp_1_xmd_app.vcxproj} |  0
 ...p_1.vcxproj => msvcp_1_xmd_kernel32.vcxproj} |  0
 ...svcp_1.vcxproj => msvcp_1_xmd_netfx.vcxproj} |  0
 ...cp_1.vcxproj => msvcp_1_xmd_onecore.vcxproj} |  0
 stl/msbuild/stl_2/dirs.proj                     |  2 +-
 stl/msbuild/stl_2/md/dirs.proj                  | 10 +++++-----
 .../msvcp_2.vcxproj => msvcp_2_md_app.vcxproj}  |  0
 ...cp_2.vcxproj => msvcp_2_md_kernel32.vcxproj} |  0
 ...msvcp_2.vcxproj => msvcp_2_md_netfx.vcxproj} |  0
 ...vcp_2.vcxproj => msvcp_2_md_onecore.vcxproj} |  0
 stl/msbuild/stl_2/msvcp_2.settings.targets      |  2 +-
 stl/msbuild/stl_2/xmd/dirs.proj                 | 10 +++++-----
 .../msvcp_2.vcxproj => msvcp_2_xmd_app.vcxproj} |  0
 ...p_2.vcxproj => msvcp_2_xmd_kernel32.vcxproj} |  0
 ...svcp_2.vcxproj => msvcp_2_xmd_netfx.vcxproj} |  0
 ...cp_2.vcxproj => msvcp_2_xmd_onecore.vcxproj} |  0
 stl/msbuild/stl_asan/dirs.proj                  |  2 +-
 stl/msbuild/stl_atomic_wait/dirs.proj           |  2 +-
 stl/msbuild/stl_atomic_wait/md/dirs.proj        | 10 +++++-----
 ...vcxproj => msvcp_atomic_wait_md_app.vcxproj} |  0
 ...oj => msvcp_atomic_wait_md_kernel32.vcxproj} |  0
 ...xproj => msvcp_atomic_wait_md_netfx.vcxproj} |  0
 ...roj => msvcp_atomic_wait_md_onecore.vcxproj} |  0
 .../msvcp_atomic_wait.settings.targets          |  2 +-
 stl/msbuild/stl_atomic_wait/xmd/dirs.proj       | 10 +++++-----
 ...cxproj => msvcp_atomic_wait_xmd_app.vcxproj} |  0
 ...j => msvcp_atomic_wait_xmd_kernel32.vcxproj} |  0
 ...proj => msvcp_atomic_wait_xmd_netfx.vcxproj} |  0
 ...oj => msvcp_atomic_wait_xmd_onecore.vcxproj} |  0
 stl/msbuild/stl_base/dirs.proj                  |  2 +-
 stl/msbuild/stl_base/md/dirs.proj               | 10 +++++-----
 .../msvcp.vcxproj => msvcp_base_md_app.vcxproj} |  0
 ...p.vcxproj => msvcp_base_md_kernel32.vcxproj} |  0
 ...svcp.vcxproj => msvcp_base_md_netfx.vcxproj} |  0
 ...cp.vcxproj => msvcp_base_md_onecore.vcxproj} |  0
 stl/msbuild/stl_base/mt/dirs.proj               |  6 +++---
 ...cpmt.vcxproj => libcpmt_mt_kernel32.vcxproj} |  0
 ...bcpmt.vcxproj => libcpmt_mt_onecore.vcxproj} |  0
 stl/msbuild/stl_base/mt1/dirs.proj              |  6 +++---
 ...pmt.vcxproj => libcpmt_mt1_kernel32.vcxproj} |  0
 ...cpmt.vcxproj => libcpmt_mt1_onecore.vcxproj} |  0
 stl/msbuild/stl_base/xmd/dirs.proj              | 10 +++++-----
 ...msvcp.vcxproj => msvcp_base_xmd_app.vcxproj} |  0
 ....vcxproj => msvcp_base_xmd_kernel32.vcxproj} |  0
 ...vcp.vcxproj => msvcp_base_xmd_netfx.vcxproj} |  0
 ...p.vcxproj => msvcp_base_xmd_onecore.vcxproj} |  0
 stl/msbuild/stl_base/xmt/dirs.proj              |  6 +++---
 ...pmt.vcxproj => libcpmt_xmt_kernel32.vcxproj} |  0
 ...cpmt.vcxproj => libcpmt_xmt_onecore.vcxproj} |  0
 stl/msbuild/stl_base/xmt0/dirs.proj             |  6 +++---
 ...mt.vcxproj => libcpmt_xmt0_kernel32.vcxproj} |  0
 ...pmt.vcxproj => libcpmt_xmt0_onecore.vcxproj} |  0
 stl/msbuild/stl_base/xmt1/dirs.proj             |  6 +++---
 ...mt.vcxproj => libcpmt_xmt1_kernel32.vcxproj} |  0
 ...pmt.vcxproj => libcpmt_xmt1_onecore.vcxproj} |  0
 stl/msbuild/stl_codecvt_ids/dirs.proj           |  2 +-
 stl/msbuild/stl_codecvt_ids/md/dirs.proj        | 10 +++++-----
 ...vcxproj => msvcp_codecvt_ids_md_app.vcxproj} |  0
 ...oj => msvcp_codecvt_ids_md_kernel32.vcxproj} |  0
 ...xproj => msvcp_codecvt_ids_md_netfx.vcxproj} |  0
 ...roj => msvcp_codecvt_ids_md_onecore.vcxproj} |  0
 .../msvcp_codecvt_ids.settings.targets          |  2 +-
 stl/msbuild/stl_codecvt_ids/xmd/dirs.proj       | 10 +++++-----
 ...cxproj => msvcp_codecvt_ids_xmd_app.vcxproj} |  0
 ...j => msvcp_codecvt_ids_xmd_kernel32.vcxproj} |  0
 ...proj => msvcp_codecvt_ids_xmd_netfx.vcxproj} |  0
 ...oj => msvcp_codecvt_ids_xmd_onecore.vcxproj} |  0
 stl/msbuild/stl_post/dirs.proj                  |  2 +-
 stl/msbuild/stl_post/md/dirs.proj               | 10 +++++-----
 ...p_post.vcxproj => msvcp_post_md_app.vcxproj} |  0
 ...t.vcxproj => msvcp_post_md_kernel32.vcxproj} |  0
 ...post.vcxproj => msvcp_post_md_netfx.vcxproj} |  0
 ...st.vcxproj => msvcp_post_md_onecore.vcxproj} |  0
 .../md/msvcp_post_netcore/msvcp_post.vcxproj    | 17 -----------------
 .../stl_post/msvcp_post.settings.targets        | 10 +++++-----
 stl/msbuild/stl_post/xmd/dirs.proj              | 10 +++++-----
 .../xmd/msvcp_post_netcore/msvcp_post.vcxproj   | 17 -----------------
 ..._post.vcxproj => msvcp_post_xmd_app.vcxproj} |  0
 ....vcxproj => msvcp_post_xmd_kernel32.vcxproj} |  0
 ...ost.vcxproj => msvcp_post_xmd_netfx.vcxproj} |  0
 ...t.vcxproj => msvcp_post_xmd_onecore.vcxproj} |  0
 89 files changed, 91 insertions(+), 125 deletions(-)
 rename stl/msbuild/stl_1/md/{msvcp_1_app/msvcp_1.vcxproj => msvcp_1_md_app.vcxproj} (100%)
 rename stl/msbuild/stl_1/md/{msvcp_1_kernel32/msvcp_1.vcxproj => msvcp_1_md_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_1/md/{msvcp_1_netfx/msvcp_1.vcxproj => msvcp_1_md_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_1/md/{msvcp_1_onecore/msvcp_1.vcxproj => msvcp_1_md_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_1/xmd/{msvcp_1_app/msvcp_1.vcxproj => msvcp_1_xmd_app.vcxproj} (100%)
 rename stl/msbuild/stl_1/xmd/{msvcp_1_kernel32/msvcp_1.vcxproj => msvcp_1_xmd_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_1/xmd/{msvcp_1_netfx/msvcp_1.vcxproj => msvcp_1_xmd_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_1/xmd/{msvcp_1_onecore/msvcp_1.vcxproj => msvcp_1_xmd_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_2/md/{msvcp_2_app/msvcp_2.vcxproj => msvcp_2_md_app.vcxproj} (100%)
 rename stl/msbuild/stl_2/md/{msvcp_2_kernel32/msvcp_2.vcxproj => msvcp_2_md_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_2/md/{msvcp_2_netfx/msvcp_2.vcxproj => msvcp_2_md_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_2/md/{msvcp_2_onecore/msvcp_2.vcxproj => msvcp_2_md_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_2/xmd/{msvcp_2_app/msvcp_2.vcxproj => msvcp_2_xmd_app.vcxproj} (100%)
 rename stl/msbuild/stl_2/xmd/{msvcp_2_kernel32/msvcp_2.vcxproj => msvcp_2_xmd_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_2/xmd/{msvcp_2_netfx/msvcp_2.vcxproj => msvcp_2_xmd_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_2/xmd/{msvcp_2_onecore/msvcp_2.vcxproj => msvcp_2_xmd_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/md/{msvcp_atomic_wait_app/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_md_app.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/md/{msvcp_atomic_wait_kernel32/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_md_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/md/{msvcp_atomic_wait_netfx/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_md_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/md/{msvcp_atomic_wait_onecore/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_md_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/xmd/{msvcp_atomic_wait_app/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_xmd_app.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/xmd/{msvcp_atomic_wait_kernel32/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_xmd_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/xmd/{msvcp_atomic_wait_netfx/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_xmd_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_atomic_wait/xmd/{msvcp_atomic_wait_onecore/msvcp_atomic_wait.vcxproj => msvcp_atomic_wait_xmd_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/md/{msvcp_app/msvcp.vcxproj => msvcp_base_md_app.vcxproj} (100%)
 rename stl/msbuild/stl_base/md/{msvcp_kernel32/msvcp.vcxproj => msvcp_base_md_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/md/{msvcp_netfx/msvcp.vcxproj => msvcp_base_md_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_base/md/{msvcp_onecore/msvcp.vcxproj => msvcp_base_md_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/mt/{libcpmt_kernel32/libcpmt.vcxproj => libcpmt_mt_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/mt/{libcpmt_onecore/libcpmt.vcxproj => libcpmt_mt_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/mt1/{libcpmt_kernel32/libcpmt.vcxproj => libcpmt_mt1_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/mt1/{libcpmt_onecore/libcpmt.vcxproj => libcpmt_mt1_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmd/{msvcp_app/msvcp.vcxproj => msvcp_base_xmd_app.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmd/{msvcp_kernel32/msvcp.vcxproj => msvcp_base_xmd_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmd/{msvcp_netfx/msvcp.vcxproj => msvcp_base_xmd_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmd/{msvcp_onecore/msvcp.vcxproj => msvcp_base_xmd_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmt/{libcpmt_kernel32/libcpmt.vcxproj => libcpmt_xmt_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmt/{libcpmt_onecore/libcpmt.vcxproj => libcpmt_xmt_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmt0/{libcpmt_kernel32/libcpmt.vcxproj => libcpmt_xmt0_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmt0/{libcpmt_onecore/libcpmt.vcxproj => libcpmt_xmt0_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmt1/{libcpmt_kernel32/libcpmt.vcxproj => libcpmt_xmt1_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_base/xmt1/{libcpmt_onecore/libcpmt.vcxproj => libcpmt_xmt1_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/md/{msvcp_codecvt_ids_app/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_md_app.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/md/{msvcp_codecvt_ids_kernel32/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_md_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/md/{msvcp_codecvt_ids_netfx/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_md_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/md/{msvcp_codecvt_ids_onecore/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_md_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/xmd/{msvcp_codecvt_ids_app/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_xmd_app.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/xmd/{msvcp_codecvt_ids_kernel32/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_xmd_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/xmd/{msvcp_codecvt_ids_netfx/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_xmd_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_codecvt_ids/xmd/{msvcp_codecvt_ids_onecore/msvcp_codecvt_ids.vcxproj => msvcp_codecvt_ids_xmd_onecore.vcxproj} (100%)
 rename stl/msbuild/stl_post/md/{msvcp_post_app/msvcp_post.vcxproj => msvcp_post_md_app.vcxproj} (100%)
 rename stl/msbuild/stl_post/md/{msvcp_post_kernel32/msvcp_post.vcxproj => msvcp_post_md_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_post/md/{msvcp_post_netfx/msvcp_post.vcxproj => msvcp_post_md_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_post/md/{msvcp_post_onecore/msvcp_post.vcxproj => msvcp_post_md_onecore.vcxproj} (100%)
 delete mode 100644 stl/msbuild/stl_post/md/msvcp_post_netcore/msvcp_post.vcxproj
 delete mode 100644 stl/msbuild/stl_post/xmd/msvcp_post_netcore/msvcp_post.vcxproj
 rename stl/msbuild/stl_post/xmd/{msvcp_post_app/msvcp_post.vcxproj => msvcp_post_xmd_app.vcxproj} (100%)
 rename stl/msbuild/stl_post/xmd/{msvcp_post_kernel32/msvcp_post.vcxproj => msvcp_post_xmd_kernel32.vcxproj} (100%)
 rename stl/msbuild/stl_post/xmd/{msvcp_post_netfx/msvcp_post.vcxproj => msvcp_post_xmd_netfx.vcxproj} (100%)
 rename stl/msbuild/stl_post/xmd/{msvcp_post_onecore/msvcp_post.vcxproj => msvcp_post_xmd_onecore.vcxproj} (100%)

diff --git a/stl/msbuild/stl_1/dirs.proj b/stl/msbuild/stl_1/dirs.proj
index 377cf679280..e177b7ccbf8 100644
--- a/stl/msbuild/stl_1/dirs.proj
+++ b/stl/msbuild/stl_1/dirs.proj
@@ -11,5 +11,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_1/md/dirs.proj b/stl/msbuild/stl_1/md/dirs.proj
index fe787e07677..d2ad61f462b 100644
--- a/stl/msbuild/stl_1/md/dirs.proj
+++ b/stl/msbuild/stl_1/md/dirs.proj
@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="msvcp_1_app\msvcp_1.vcxproj" />
-        <ProjectFile Include="msvcp_1_kernel32\msvcp_1.vcxproj" />
-        <ProjectFile Include="msvcp_1_onecore\msvcp_1.vcxproj" />
-        <ProjectFile Include="msvcp_1_netfx\msvcp_1.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_1_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_1_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_1_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_1_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_1/md/msvcp_1_app/msvcp_1.vcxproj b/stl/msbuild/stl_1/md/msvcp_1_md_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/md/msvcp_1_app/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/md/msvcp_1_md_app.vcxproj
diff --git a/stl/msbuild/stl_1/md/msvcp_1_kernel32/msvcp_1.vcxproj b/stl/msbuild/stl_1/md/msvcp_1_md_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/md/msvcp_1_kernel32/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/md/msvcp_1_md_kernel32.vcxproj
diff --git a/stl/msbuild/stl_1/md/msvcp_1_netfx/msvcp_1.vcxproj b/stl/msbuild/stl_1/md/msvcp_1_md_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/md/msvcp_1_netfx/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/md/msvcp_1_md_netfx.vcxproj
diff --git a/stl/msbuild/stl_1/md/msvcp_1_onecore/msvcp_1.vcxproj b/stl/msbuild/stl_1/md/msvcp_1_md_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/md/msvcp_1_onecore/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/md/msvcp_1_md_onecore.vcxproj
diff --git a/stl/msbuild/stl_1/msvcp_1.settings.targets b/stl/msbuild/stl_1/msvcp_1.settings.targets
index 220ac4b9186..30d8178cbeb 100644
--- a/stl/msbuild/stl_1/msvcp_1.settings.targets
+++ b/stl/msbuild/stl_1/msvcp_1.settings.targets
@@ -64,7 +64,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_$(MsvcpFlavor)\msvcp.vcxproj"/>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
diff --git a/stl/msbuild/stl_1/xmd/dirs.proj b/stl/msbuild/stl_1/xmd/dirs.proj
index 8ceb699344f..f9b3be319d5 100644
--- a/stl/msbuild/stl_1/xmd/dirs.proj
+++ b/stl/msbuild/stl_1/xmd/dirs.proj
@@ -9,14 +9,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <ItemGroup Condition="('$(SpectreBuildMode)' == '' or
                            '$(Configuration)' == 'chk' or
                            '$(Configuration)' == 'dbg')">
-        <ProjectFile Include="msvcp_1_app\msvcp_1.vcxproj" />
-        <ProjectFile Include="msvcp_1_kernel32\msvcp_1.vcxproj" />
-        <ProjectFile Include="msvcp_1_onecore\msvcp_1.vcxproj" />
+        <ProjectFile Include="msvcp_1_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_1_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_1_xmd_onecore.vcxproj" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
-        <ProjectFile Include="msvcp_1_netfx\msvcp_1.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_1_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_1/xmd/msvcp_1_app/msvcp_1.vcxproj b/stl/msbuild/stl_1/xmd/msvcp_1_xmd_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/xmd/msvcp_1_app/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/xmd/msvcp_1_xmd_app.vcxproj
diff --git a/stl/msbuild/stl_1/xmd/msvcp_1_kernel32/msvcp_1.vcxproj b/stl/msbuild/stl_1/xmd/msvcp_1_xmd_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/xmd/msvcp_1_kernel32/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/xmd/msvcp_1_xmd_kernel32.vcxproj
diff --git a/stl/msbuild/stl_1/xmd/msvcp_1_netfx/msvcp_1.vcxproj b/stl/msbuild/stl_1/xmd/msvcp_1_xmd_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/xmd/msvcp_1_netfx/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/xmd/msvcp_1_xmd_netfx.vcxproj
diff --git a/stl/msbuild/stl_1/xmd/msvcp_1_onecore/msvcp_1.vcxproj b/stl/msbuild/stl_1/xmd/msvcp_1_xmd_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_1/xmd/msvcp_1_onecore/msvcp_1.vcxproj
rename to stl/msbuild/stl_1/xmd/msvcp_1_xmd_onecore.vcxproj
diff --git a/stl/msbuild/stl_2/dirs.proj b/stl/msbuild/stl_2/dirs.proj
index 377cf679280..e177b7ccbf8 100644
--- a/stl/msbuild/stl_2/dirs.proj
+++ b/stl/msbuild/stl_2/dirs.proj
@@ -11,5 +11,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_2/md/dirs.proj b/stl/msbuild/stl_2/md/dirs.proj
index 806a2be293a..4541ab79eb7 100644
--- a/stl/msbuild/stl_2/md/dirs.proj
+++ b/stl/msbuild/stl_2/md/dirs.proj
@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="msvcp_2_app\msvcp_2.vcxproj" />
-        <ProjectFile Include="msvcp_2_kernel32\msvcp_2.vcxproj" />
-        <ProjectFile Include="msvcp_2_onecore\msvcp_2.vcxproj" />
-        <ProjectFile Include="msvcp_2_netfx\msvcp_2.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_2_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_2_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_2_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_2_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_2/md/msvcp_2_app/msvcp_2.vcxproj b/stl/msbuild/stl_2/md/msvcp_2_md_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/md/msvcp_2_app/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/md/msvcp_2_md_app.vcxproj
diff --git a/stl/msbuild/stl_2/md/msvcp_2_kernel32/msvcp_2.vcxproj b/stl/msbuild/stl_2/md/msvcp_2_md_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/md/msvcp_2_kernel32/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/md/msvcp_2_md_kernel32.vcxproj
diff --git a/stl/msbuild/stl_2/md/msvcp_2_netfx/msvcp_2.vcxproj b/stl/msbuild/stl_2/md/msvcp_2_md_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/md/msvcp_2_netfx/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/md/msvcp_2_md_netfx.vcxproj
diff --git a/stl/msbuild/stl_2/md/msvcp_2_onecore/msvcp_2.vcxproj b/stl/msbuild/stl_2/md/msvcp_2_md_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/md/msvcp_2_onecore/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/md/msvcp_2_md_onecore.vcxproj
diff --git a/stl/msbuild/stl_2/msvcp_2.settings.targets b/stl/msbuild/stl_2/msvcp_2.settings.targets
index baf640e73e7..a5c2fd53b56 100644
--- a/stl/msbuild/stl_2/msvcp_2.settings.targets
+++ b/stl/msbuild/stl_2/msvcp_2.settings.targets
@@ -64,7 +64,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_$(MsvcpFlavor)\msvcp.vcxproj"/>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
diff --git a/stl/msbuild/stl_2/xmd/dirs.proj b/stl/msbuild/stl_2/xmd/dirs.proj
index 420d911ebfc..32c9b10fc32 100644
--- a/stl/msbuild/stl_2/xmd/dirs.proj
+++ b/stl/msbuild/stl_2/xmd/dirs.proj
@@ -9,14 +9,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <ItemGroup Condition="('$(SpectreBuildMode)' == '' or
                            '$(Configuration)' == 'chk' or
                            '$(Configuration)' == 'dbg')">
-        <ProjectFile Include="msvcp_2_app\msvcp_2.vcxproj" />
-        <ProjectFile Include="msvcp_2_kernel32\msvcp_2.vcxproj" />
-        <ProjectFile Include="msvcp_2_onecore\msvcp_2.vcxproj" />
+        <ProjectFile Include="msvcp_2_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_2_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_2_xmd_onecore.vcxproj" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
-        <ProjectFile Include="msvcp_2_netfx\msvcp_2.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_2_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_2/xmd/msvcp_2_app/msvcp_2.vcxproj b/stl/msbuild/stl_2/xmd/msvcp_2_xmd_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/xmd/msvcp_2_app/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/xmd/msvcp_2_xmd_app.vcxproj
diff --git a/stl/msbuild/stl_2/xmd/msvcp_2_kernel32/msvcp_2.vcxproj b/stl/msbuild/stl_2/xmd/msvcp_2_xmd_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/xmd/msvcp_2_kernel32/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/xmd/msvcp_2_xmd_kernel32.vcxproj
diff --git a/stl/msbuild/stl_2/xmd/msvcp_2_netfx/msvcp_2.vcxproj b/stl/msbuild/stl_2/xmd/msvcp_2_xmd_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/xmd/msvcp_2_netfx/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/xmd/msvcp_2_xmd_netfx.vcxproj
diff --git a/stl/msbuild/stl_2/xmd/msvcp_2_onecore/msvcp_2.vcxproj b/stl/msbuild/stl_2/xmd/msvcp_2_xmd_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_2/xmd/msvcp_2_onecore/msvcp_2.vcxproj
rename to stl/msbuild/stl_2/xmd/msvcp_2_xmd_onecore.vcxproj
diff --git a/stl/msbuild/stl_asan/dirs.proj b/stl/msbuild/stl_asan/dirs.proj
index 528fa0815df..d921f685527 100644
--- a/stl/msbuild/stl_asan/dirs.proj
+++ b/stl/msbuild/stl_asan/dirs.proj
@@ -10,5 +10,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Include="stl_asan.vcxproj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_atomic_wait/dirs.proj b/stl/msbuild/stl_atomic_wait/dirs.proj
index 377cf679280..e177b7ccbf8 100644
--- a/stl/msbuild/stl_atomic_wait/dirs.proj
+++ b/stl/msbuild/stl_atomic_wait/dirs.proj
@@ -11,5 +11,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_atomic_wait/md/dirs.proj b/stl/msbuild/stl_atomic_wait/md/dirs.proj
index 7d53392a298..03b6a18835d 100644
--- a/stl/msbuild/stl_atomic_wait/md/dirs.proj
+++ b/stl/msbuild/stl_atomic_wait/md/dirs.proj
@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="msvcp_atomic_wait_app\msvcp_atomic_wait.vcxproj" />
-        <ProjectFile Include="msvcp_atomic_wait_kernel32\msvcp_atomic_wait.vcxproj" />
-        <ProjectFile Include="msvcp_atomic_wait_onecore\msvcp_atomic_wait.vcxproj" />
-        <ProjectFile Include="msvcp_atomic_wait_netfx\msvcp_atomic_wait.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_atomic_wait_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_app/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_app/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_app.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_kernel32/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_kernel32/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_kernel32.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_netfx/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_netfx/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_netfx.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_onecore/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_onecore/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/md/msvcp_atomic_wait_md_onecore.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets b/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
index 53112fa8cda..869f8a1ecd2 100644
--- a/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
+++ b/stl/msbuild/stl_atomic_wait/msvcp_atomic_wait.settings.targets
@@ -64,7 +64,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_$(MsvcpFlavor)\msvcp.vcxproj"/>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
diff --git a/stl/msbuild/stl_atomic_wait/xmd/dirs.proj b/stl/msbuild/stl_atomic_wait/xmd/dirs.proj
index 2fad5e7e478..2e5c24526f3 100644
--- a/stl/msbuild/stl_atomic_wait/xmd/dirs.proj
+++ b/stl/msbuild/stl_atomic_wait/xmd/dirs.proj
@@ -9,14 +9,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <ItemGroup Condition="('$(SpectreBuildMode)' == '' or
                            '$(Configuration)' == 'chk' or
                            '$(Configuration)' == 'dbg')">
-        <ProjectFile Include="msvcp_atomic_wait_app\msvcp_atomic_wait.vcxproj" />
-        <ProjectFile Include="msvcp_atomic_wait_kernel32\msvcp_atomic_wait.vcxproj" />
-        <ProjectFile Include="msvcp_atomic_wait_onecore\msvcp_atomic_wait.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_atomic_wait_xmd_onecore.vcxproj" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
-        <ProjectFile Include="msvcp_atomic_wait_netfx\msvcp_atomic_wait.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_atomic_wait_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_app/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_app/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_app.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_kernel32/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_kernel32/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_kernel32.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_netfx/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_netfx/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_netfx.vcxproj
diff --git a/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_onecore/msvcp_atomic_wait.vcxproj b/stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_onecore/msvcp_atomic_wait.vcxproj
rename to stl/msbuild/stl_atomic_wait/xmd/msvcp_atomic_wait_xmd_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/dirs.proj b/stl/msbuild/stl_base/dirs.proj
index 5b0b5de7857..a46ac76b51f 100644
--- a/stl/msbuild/stl_base/dirs.proj
+++ b/stl/msbuild/stl_base/dirs.proj
@@ -16,5 +16,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(CrtBuildXMT)' != 'false' and '$(SpectreBuildMode)' == ''" Include="xmt1\dirs.proj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/md/dirs.proj b/stl/msbuild/stl_base/md/dirs.proj
index 32c71e4692f..d43e6cabae2 100644
--- a/stl/msbuild/stl_base/md/dirs.proj
+++ b/stl/msbuild/stl_base/md/dirs.proj
@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="msvcp_app\msvcp.vcxproj" />
-        <ProjectFile Include="msvcp_kernel32\msvcp.vcxproj" />
-        <ProjectFile Include="msvcp_onecore\msvcp.vcxproj" />
-        <ProjectFile Include="msvcp_netfx\msvcp.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_base_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_base_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_base_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_base_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/md/msvcp_app/msvcp.vcxproj b/stl/msbuild/stl_base/md/msvcp_base_md_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/md/msvcp_app/msvcp.vcxproj
rename to stl/msbuild/stl_base/md/msvcp_base_md_app.vcxproj
diff --git a/stl/msbuild/stl_base/md/msvcp_kernel32/msvcp.vcxproj b/stl/msbuild/stl_base/md/msvcp_base_md_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/md/msvcp_kernel32/msvcp.vcxproj
rename to stl/msbuild/stl_base/md/msvcp_base_md_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/md/msvcp_netfx/msvcp.vcxproj b/stl/msbuild/stl_base/md/msvcp_base_md_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/md/msvcp_netfx/msvcp.vcxproj
rename to stl/msbuild/stl_base/md/msvcp_base_md_netfx.vcxproj
diff --git a/stl/msbuild/stl_base/md/msvcp_onecore/msvcp.vcxproj b/stl/msbuild/stl_base/md/msvcp_base_md_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/md/msvcp_onecore/msvcp.vcxproj
rename to stl/msbuild/stl_base/md/msvcp_base_md_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/mt/dirs.proj b/stl/msbuild/stl_base/mt/dirs.proj
index 68f29ec0dd0..cbdcba1de69 100644
--- a/stl/msbuild/stl_base/mt/dirs.proj
+++ b/stl/msbuild/stl_base/mt/dirs.proj
@@ -7,9 +7,9 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="libcpmt_kernel32\libcpmt.vcxproj" />
-        <ProjectFile Include="libcpmt_onecore\libcpmt.vcxproj" />
+        <ProjectFile Include="libcpmt_mt_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_mt_onecore.vcxproj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/mt/libcpmt_kernel32/libcpmt.vcxproj b/stl/msbuild/stl_base/mt/libcpmt_mt_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/mt/libcpmt_kernel32/libcpmt.vcxproj
rename to stl/msbuild/stl_base/mt/libcpmt_mt_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/mt/libcpmt_onecore/libcpmt.vcxproj b/stl/msbuild/stl_base/mt/libcpmt_mt_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/mt/libcpmt_onecore/libcpmt.vcxproj
rename to stl/msbuild/stl_base/mt/libcpmt_mt_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/mt1/dirs.proj b/stl/msbuild/stl_base/mt1/dirs.proj
index 68f29ec0dd0..bb5db98dfe4 100644
--- a/stl/msbuild/stl_base/mt1/dirs.proj
+++ b/stl/msbuild/stl_base/mt1/dirs.proj
@@ -7,9 +7,9 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="libcpmt_kernel32\libcpmt.vcxproj" />
-        <ProjectFile Include="libcpmt_onecore\libcpmt.vcxproj" />
+        <ProjectFile Include="libcpmt_mt1_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_mt1_onecore.vcxproj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/mt1/libcpmt_kernel32/libcpmt.vcxproj b/stl/msbuild/stl_base/mt1/libcpmt_mt1_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/mt1/libcpmt_kernel32/libcpmt.vcxproj
rename to stl/msbuild/stl_base/mt1/libcpmt_mt1_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/mt1/libcpmt_onecore/libcpmt.vcxproj b/stl/msbuild/stl_base/mt1/libcpmt_mt1_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/mt1/libcpmt_onecore/libcpmt.vcxproj
rename to stl/msbuild/stl_base/mt1/libcpmt_mt1_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/xmd/dirs.proj b/stl/msbuild/stl_base/xmd/dirs.proj
index f14091bd657..b1948b2b1ff 100644
--- a/stl/msbuild/stl_base/xmd/dirs.proj
+++ b/stl/msbuild/stl_base/xmd/dirs.proj
@@ -10,14 +10,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
                            '$(Configuration)' == 'chk' or
                            '$(Configuration)' == 'dbg')">
         <!-- Other components in dbg and chk builds depend on msvcprtd.lib -->
-        <ProjectFile Include="msvcp_app\msvcp.vcxproj" />
-        <ProjectFile Include="msvcp_kernel32\msvcp.vcxproj" />
-        <ProjectFile Include="msvcp_onecore\msvcp.vcxproj" />
+        <ProjectFile Include="msvcp_base_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_base_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_base_xmd_onecore.vcxproj" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
-        <ProjectFile Include="msvcp_netfx\msvcp.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_base_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/xmd/msvcp_app/msvcp.vcxproj b/stl/msbuild/stl_base/xmd/msvcp_base_xmd_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmd/msvcp_app/msvcp.vcxproj
rename to stl/msbuild/stl_base/xmd/msvcp_base_xmd_app.vcxproj
diff --git a/stl/msbuild/stl_base/xmd/msvcp_kernel32/msvcp.vcxproj b/stl/msbuild/stl_base/xmd/msvcp_base_xmd_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmd/msvcp_kernel32/msvcp.vcxproj
rename to stl/msbuild/stl_base/xmd/msvcp_base_xmd_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/xmd/msvcp_netfx/msvcp.vcxproj b/stl/msbuild/stl_base/xmd/msvcp_base_xmd_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmd/msvcp_netfx/msvcp.vcxproj
rename to stl/msbuild/stl_base/xmd/msvcp_base_xmd_netfx.vcxproj
diff --git a/stl/msbuild/stl_base/xmd/msvcp_onecore/msvcp.vcxproj b/stl/msbuild/stl_base/xmd/msvcp_base_xmd_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmd/msvcp_onecore/msvcp.vcxproj
rename to stl/msbuild/stl_base/xmd/msvcp_base_xmd_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/xmt/dirs.proj b/stl/msbuild/stl_base/xmt/dirs.proj
index 4a49a0688dd..336c1a96edb 100644
--- a/stl/msbuild/stl_base/xmt/dirs.proj
+++ b/stl/msbuild/stl_base/xmt/dirs.proj
@@ -10,9 +10,9 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(SpectreBuildMode)' == '' or
                                 '$(Configuration)' == 'chk' or
                                 '$(Configuration)' == 'dbg'"
-                     Include="libcpmt_kernel32\libcpmt.vcxproj" />
-        <ProjectFile Condition="'$(SpectreBuildMode)' == ''" Include="libcpmt_onecore\libcpmt.vcxproj" />
+                     Include="libcpmt_xmt_kernel32.vcxproj" />
+        <ProjectFile Condition="'$(SpectreBuildMode)' == ''" Include="libcpmt_xmt_onecore.vcxproj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/xmt/libcpmt_kernel32/libcpmt.vcxproj b/stl/msbuild/stl_base/xmt/libcpmt_xmt_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmt/libcpmt_kernel32/libcpmt.vcxproj
rename to stl/msbuild/stl_base/xmt/libcpmt_xmt_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/xmt/libcpmt_onecore/libcpmt.vcxproj b/stl/msbuild/stl_base/xmt/libcpmt_xmt_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmt/libcpmt_onecore/libcpmt.vcxproj
rename to stl/msbuild/stl_base/xmt/libcpmt_xmt_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/xmt0/dirs.proj b/stl/msbuild/stl_base/xmt0/dirs.proj
index 68f29ec0dd0..61bdba149b7 100644
--- a/stl/msbuild/stl_base/xmt0/dirs.proj
+++ b/stl/msbuild/stl_base/xmt0/dirs.proj
@@ -7,9 +7,9 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="libcpmt_kernel32\libcpmt.vcxproj" />
-        <ProjectFile Include="libcpmt_onecore\libcpmt.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt0_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt0_onecore.vcxproj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/xmt0/libcpmt_kernel32/libcpmt.vcxproj b/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmt0/libcpmt_kernel32/libcpmt.vcxproj
rename to stl/msbuild/stl_base/xmt0/libcpmt_xmt0_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/xmt0/libcpmt_onecore/libcpmt.vcxproj b/stl/msbuild/stl_base/xmt0/libcpmt_xmt0_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmt0/libcpmt_onecore/libcpmt.vcxproj
rename to stl/msbuild/stl_base/xmt0/libcpmt_xmt0_onecore.vcxproj
diff --git a/stl/msbuild/stl_base/xmt1/dirs.proj b/stl/msbuild/stl_base/xmt1/dirs.proj
index 68f29ec0dd0..8dd8f99c43a 100644
--- a/stl/msbuild/stl_base/xmt1/dirs.proj
+++ b/stl/msbuild/stl_base/xmt1/dirs.proj
@@ -7,9 +7,9 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="libcpmt_kernel32\libcpmt.vcxproj" />
-        <ProjectFile Include="libcpmt_onecore\libcpmt.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt1_kernel32.vcxproj" />
+        <ProjectFile Include="libcpmt_xmt1_onecore.vcxproj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_base/xmt1/libcpmt_kernel32/libcpmt.vcxproj b/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmt1/libcpmt_kernel32/libcpmt.vcxproj
rename to stl/msbuild/stl_base/xmt1/libcpmt_xmt1_kernel32.vcxproj
diff --git a/stl/msbuild/stl_base/xmt1/libcpmt_onecore/libcpmt.vcxproj b/stl/msbuild/stl_base/xmt1/libcpmt_xmt1_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_base/xmt1/libcpmt_onecore/libcpmt.vcxproj
rename to stl/msbuild/stl_base/xmt1/libcpmt_xmt1_onecore.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/dirs.proj b/stl/msbuild/stl_codecvt_ids/dirs.proj
index 377cf679280..e177b7ccbf8 100644
--- a/stl/msbuild/stl_codecvt_ids/dirs.proj
+++ b/stl/msbuild/stl_codecvt_ids/dirs.proj
@@ -11,5 +11,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_codecvt_ids/md/dirs.proj b/stl/msbuild/stl_codecvt_ids/md/dirs.proj
index ce06a7e913f..de1bf9fc373 100644
--- a/stl/msbuild/stl_codecvt_ids/md/dirs.proj
+++ b/stl/msbuild/stl_codecvt_ids/md/dirs.proj
@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="msvcp_codecvt_ids_app\msvcp_codecvt_ids.vcxproj" />
-        <ProjectFile Include="msvcp_codecvt_ids_kernel32\msvcp_codecvt_ids.vcxproj" />
-        <ProjectFile Include="msvcp_codecvt_ids_onecore\msvcp_codecvt_ids.vcxproj" />
-        <ProjectFile Include="msvcp_codecvt_ids_netfx\msvcp_codecvt_ids.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_app/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_app/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_app.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_kernel32/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_kernel32/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_kernel32.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_netfx/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_netfx/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_netfx.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_onecore/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_onecore/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/md/msvcp_codecvt_ids_md_onecore.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets b/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets
index 5496e00a64e..6d1166d0606 100644
--- a/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets
+++ b/stl/msbuild/stl_codecvt_ids/msvcp_codecvt_ids.settings.targets
@@ -64,7 +64,7 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     </ItemGroup>
 
     <ItemGroup>
-        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_$(MsvcpFlavor)\msvcp.vcxproj"/>
+        <ProjectReference Condition="'$(CrtBuildModel)'=='md' or '$(CrtBuildModel)'=='xmd'" Include="$(VCToolsRootPath)\crt\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <TargetLib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\msvcrt$(BuildSuffix)$(ClrLibSuffix).lib"/>
         <TargetLib Include="$(CrtLibPath)\vcruntime$(BuildSuffix)$(ClrLibSuffix).lib"/>
diff --git a/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj b/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj
index 5d2cb21ae2e..f87e96750c8 100644
--- a/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj
+++ b/stl/msbuild/stl_codecvt_ids/xmd/dirs.proj
@@ -9,14 +9,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <ItemGroup Condition="('$(SpectreBuildMode)' == '' or
                            '$(Configuration)' == 'chk' or
                            '$(Configuration)' == 'dbg')">
-        <ProjectFile Include="msvcp_codecvt_ids_app\msvcp_codecvt_ids.vcxproj" />
-        <ProjectFile Include="msvcp_codecvt_ids_kernel32\msvcp_codecvt_ids.vcxproj" />
-        <ProjectFile Include="msvcp_codecvt_ids_onecore\msvcp_codecvt_ids.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_onecore.vcxproj" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
-        <ProjectFile Include="msvcp_codecvt_ids_netfx\msvcp_codecvt_ids.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe' and '$(BuildArchitecture)' != 'arm64ec'" />
+        <ProjectFile Include="msvcp_codecvt_ids_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe' and '$(BuildArchitecture)' != 'arm64ec'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_app/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_app/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_app.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_kernel32/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_kernel32/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_kernel32.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_netfx/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_netfx/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_netfx.vcxproj
diff --git a/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_onecore/msvcp_codecvt_ids.vcxproj b/stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_onecore/msvcp_codecvt_ids.vcxproj
rename to stl/msbuild/stl_codecvt_ids/xmd/msvcp_codecvt_ids_xmd_onecore.vcxproj
diff --git a/stl/msbuild/stl_post/dirs.proj b/stl/msbuild/stl_post/dirs.proj
index 377cf679280..e177b7ccbf8 100644
--- a/stl/msbuild/stl_post/dirs.proj
+++ b/stl/msbuild/stl_post/dirs.proj
@@ -11,5 +11,5 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
         <ProjectFile Condition="'$(CrtBuildXMD)' != 'false'" Include="xmd\dirs.proj" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_post/md/dirs.proj b/stl/msbuild/stl_post/md/dirs.proj
index c595b67cdfb..9a4ec8b5057 100644
--- a/stl/msbuild/stl_post/md/dirs.proj
+++ b/stl/msbuild/stl_post/md/dirs.proj
@@ -7,11 +7,11 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <Import Project="$(MSBuildThisFileDirectory)..\..\..\..\..\crt-common.settings.targets" />
 
     <ItemGroup>
-        <ProjectFile Include="msvcp_post_app\msvcp_post.vcxproj" />
-        <ProjectFile Include="msvcp_post_kernel32\msvcp_post.vcxproj" />
-        <ProjectFile Include="msvcp_post_onecore\msvcp_post.vcxproj" />
-        <ProjectFile Include="msvcp_post_netfx\msvcp_post.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_post_md_app.vcxproj" />
+        <ProjectFile Include="msvcp_post_md_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_post_md_onecore.vcxproj" />
+        <ProjectFile Include="msvcp_post_md_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_post/md/msvcp_post_app/msvcp_post.vcxproj b/stl/msbuild/stl_post/md/msvcp_post_md_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/md/msvcp_post_app/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/md/msvcp_post_md_app.vcxproj
diff --git a/stl/msbuild/stl_post/md/msvcp_post_kernel32/msvcp_post.vcxproj b/stl/msbuild/stl_post/md/msvcp_post_md_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/md/msvcp_post_kernel32/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/md/msvcp_post_md_kernel32.vcxproj
diff --git a/stl/msbuild/stl_post/md/msvcp_post_netfx/msvcp_post.vcxproj b/stl/msbuild/stl_post/md/msvcp_post_md_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/md/msvcp_post_netfx/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/md/msvcp_post_md_netfx.vcxproj
diff --git a/stl/msbuild/stl_post/md/msvcp_post_onecore/msvcp_post.vcxproj b/stl/msbuild/stl_post/md/msvcp_post_md_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/md/msvcp_post_onecore/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/md/msvcp_post_md_onecore.vcxproj
diff --git a/stl/msbuild/stl_post/md/msvcp_post_netcore/msvcp_post.vcxproj b/stl/msbuild/stl_post/md/msvcp_post_netcore/msvcp_post.vcxproj
deleted file mode 100644
index 02a2d665819..00000000000
--- a/stl/msbuild/stl_post/md/msvcp_post_netcore/msvcp_post.vcxproj
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <!--
-  Copyright (c) Microsoft Corporation.
-  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-  -->
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{F6BF440E-AA43-48D1-A7BF-53ED43ED2C6F}</ProjectGuid>
-  </PropertyGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
-  <PropertyGroup>
-    <CrtBuildModel>md</CrtBuildModel>
-    <MsvcpFlavor>kernel32</MsvcpFlavor>
-    <Arm64X>true</Arm64X>
-  </PropertyGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
-</Project>
diff --git a/stl/msbuild/stl_post/msvcp_post.settings.targets b/stl/msbuild/stl_post/msvcp_post.settings.targets
index 7a2384cb36a..0f211b5118c 100644
--- a/stl/msbuild/stl_post/msvcp_post.settings.targets
+++ b/stl/msbuild/stl_post/msvcp_post.settings.targets
@@ -44,15 +44,15 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
     <ItemGroup>
         <ProjectReference
-            Include="$(CrtRoot)\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_$(MsvcpFlavor)\msvcp.vcxproj"/>
+            Include="$(CrtRoot)\github\stl\msbuild\stl_base\$(CrtBuildModel)\msvcp_base_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <ProjectReference
-            Include="$(CrtRoot)\github\stl\msbuild\stl_1\$(CrtBuildModel)\msvcp_1_$(MsvcpFlavor)\msvcp_1.vcxproj"/>
+            Include="$(CrtRoot)\github\stl\msbuild\stl_1\$(CrtBuildModel)\msvcp_1_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <ProjectReference
-            Include="$(CrtRoot)\github\stl\msbuild\stl_2\$(CrtBuildModel)\msvcp_2_$(MsvcpFlavor)\msvcp_2.vcxproj"/>
+            Include="$(CrtRoot)\github\stl\msbuild\stl_2\$(CrtBuildModel)\msvcp_2_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <ProjectReference
-            Include="$(CrtRoot)\github\stl\msbuild\stl_codecvt_ids\$(CrtBuildModel)\msvcp_codecvt_ids_$(MsvcpFlavor)\msvcp_codecvt_ids.vcxproj"/>
+            Include="$(CrtRoot)\github\stl\msbuild\stl_codecvt_ids\$(CrtBuildModel)\msvcp_codecvt_ids_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <ProjectReference
-            Include="$(CrtRoot)\github\stl\msbuild\stl_atomic_wait\$(CrtBuildModel)\msvcp_atomic_wait_$(MsvcpFlavor)\msvcp_atomic_wait.vcxproj"/>
+            Include="$(CrtRoot)\github\stl\msbuild\stl_atomic_wait\$(CrtBuildModel)\msvcp_atomic_wait_$(CrtBuildModel)_$(MsvcpFlavor).vcxproj"/>
         <Lib Include="$(CrtLibPath)\msvcprt_base$(BuildSuffix)$(ClrLibSuffix).lib">
             <IncludeInChameleonLib>false</IncludeInChameleonLib>
         </Lib>
diff --git a/stl/msbuild/stl_post/xmd/dirs.proj b/stl/msbuild/stl_post/xmd/dirs.proj
index f29b09dd84c..40f86dd45ae 100644
--- a/stl/msbuild/stl_post/xmd/dirs.proj
+++ b/stl/msbuild/stl_post/xmd/dirs.proj
@@ -9,14 +9,14 @@ SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
     <ItemGroup Condition="('$(SpectreBuildMode)' == '' or
                            '$(Configuration)' == 'chk' or
                            '$(Configuration)' == 'dbg')">
-        <ProjectFile Include="msvcp_post_app\msvcp_post.vcxproj" />
-        <ProjectFile Include="msvcp_post_kernel32\msvcp_post.vcxproj" />
-        <ProjectFile Include="msvcp_post_onecore\msvcp_post.vcxproj" />
+        <ProjectFile Include="msvcp_post_xmd_app.vcxproj" />
+        <ProjectFile Include="msvcp_post_xmd_kernel32.vcxproj" />
+        <ProjectFile Include="msvcp_post_xmd_onecore.vcxproj" />
     </ItemGroup>
 
     <ItemGroup Condition="'$(SpectreBuildMode)' == ''">
-        <ProjectFile Include="msvcp_post_netfx\msvcp_post.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
+        <ProjectFile Include="msvcp_post_xmd_netfx.vcxproj" Condition="'$(BuildArchitecture)' != 'chpe'" />
     </ItemGroup>
 
-    <Import Project="$(RepoSrc)\tools\Microsoft.DevDiv.Traversal.targets" />
+    <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Traversal.targets))" />
 </Project>
diff --git a/stl/msbuild/stl_post/xmd/msvcp_post_netcore/msvcp_post.vcxproj b/stl/msbuild/stl_post/xmd/msvcp_post_netcore/msvcp_post.vcxproj
deleted file mode 100644
index 95d21bde6bc..00000000000
--- a/stl/msbuild/stl_post/xmd/msvcp_post_netcore/msvcp_post.vcxproj
+++ /dev/null
@@ -1,17 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" ToolsVersion="Dogfood" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <!--
-  Copyright (c) Microsoft Corporation.
-  SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-  -->
-  <PropertyGroup Label="Globals">
-    <ProjectGuid>{EC379541-9453-4884-9250-3CDBA73E2C10}</ProjectGuid>
-  </PropertyGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(VCTools.Cpp.Default.props))" />
-  <PropertyGroup>
-    <CrtBuildModel>xmd</CrtBuildModel>
-    <MsvcpFlavor>kernel32</MsvcpFlavor>
-    <Arm64X>true</Arm64X>
-  </PropertyGroup>
-  <Import Project="$([MSBuild]::GetPathOfFileAbove(msvcp_post.settings.targets))" />
-</Project>
diff --git a/stl/msbuild/stl_post/xmd/msvcp_post_app/msvcp_post.vcxproj b/stl/msbuild/stl_post/xmd/msvcp_post_xmd_app.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/xmd/msvcp_post_app/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/xmd/msvcp_post_xmd_app.vcxproj
diff --git a/stl/msbuild/stl_post/xmd/msvcp_post_kernel32/msvcp_post.vcxproj b/stl/msbuild/stl_post/xmd/msvcp_post_xmd_kernel32.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/xmd/msvcp_post_kernel32/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/xmd/msvcp_post_xmd_kernel32.vcxproj
diff --git a/stl/msbuild/stl_post/xmd/msvcp_post_netfx/msvcp_post.vcxproj b/stl/msbuild/stl_post/xmd/msvcp_post_xmd_netfx.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/xmd/msvcp_post_netfx/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/xmd/msvcp_post_xmd_netfx.vcxproj
diff --git a/stl/msbuild/stl_post/xmd/msvcp_post_onecore/msvcp_post.vcxproj b/stl/msbuild/stl_post/xmd/msvcp_post_xmd_onecore.vcxproj
similarity index 100%
rename from stl/msbuild/stl_post/xmd/msvcp_post_onecore/msvcp_post.vcxproj
rename to stl/msbuild/stl_post/xmd/msvcp_post_xmd_onecore.vcxproj

From 1e7d7f8d601212df48b553c7e95bc0e39b5377e8 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 21 Mar 2024 23:44:33 +0200
Subject: [PATCH 07/45] Auto vectorize `replace_copy`, `replace_copy_if`
 (#4431)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/CMakeLists.txt  |  1 +
 benchmarks/src/replace.cpp | 71 ++++++++++++++++++++++++++++++++++++++
 stl/inc/algorithm          | 49 +++++++++++++++++++-------
 3 files changed, 109 insertions(+), 12 deletions(-)
 create mode 100644 benchmarks/src/replace.cpp

diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index 2903ee13245..498ddb90f4a 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -115,6 +115,7 @@ add_benchmark(minmax_element src/minmax_element.cpp)
 add_benchmark(path_lexically_normal src/path_lexically_normal.cpp)
 add_benchmark(priority_queue_push_range src/priority_queue_push_range.cpp)
 add_benchmark(random_integer_generation src/random_integer_generation.cpp)
+add_benchmark(replace src/replace.cpp)
 add_benchmark(std_copy src/std_copy.cpp)
 
 add_benchmark(vector_bool_copy src/std/containers/sequences/vector.bool/copy/test.cpp)
diff --git a/benchmarks/src/replace.cpp b/benchmarks/src/replace.cpp
new file mode 100644
index 00000000000..8fc66ab7841
--- /dev/null
+++ b/benchmarks/src/replace.cpp
@@ -0,0 +1,71 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <cstdint>
+#include <vector>
+
+const char src[] =
+    "Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nullam mollis imperdiet massa, at dapibus elit interdum "
+    "ac. In eget sollicitudin mi. Nam at tellus at sapien tincidunt sollicitudin vel non eros. Pellentesque nunc nunc, "
+    "ullamcorper eu accumsan at, pulvinar non turpis. Quisque vel mauris pulvinar, pretium purus vel, ultricies erat. "
+    "Curabitur a magna in ligula tristique ornare. Quisque commodo, massa viverra laoreet luctus, sem nisi aliquet "
+    "velit, fermentum pulvinar velit leo eget justo. Suspendisse vel erat efficitur, pulvinar eros volutpat, vulputate "
+    "ex. Phasellus non purus vel velit tristique tristique id at ligula. Quisque mollis sodales magna. Mauris et quam "
+    "eu quam viverra tempus. Nullam tempus maximus porta. Nunc mattis eleifend fermentum. Nullam aliquam libero "
+    "accumsan velit elementum, eu laoreet metus convallis. Donec pellentesque lacus ut iaculis iaculis. Curabitur orci "
+    "elit, bibendum sit amet feugiat at, iaculis sit amet massa. Maecenas imperdiet lacus at vehicula iaculis. Donec "
+    "volutpat nunc sit amet accumsan tempor. Quisque pretium vestibulum ultricies. Suspendisse potenti. Aenean at diam "
+    "iaculis, condimentum felis venenatis, condimentum erat. Nam quis elit dui. Duis quis odio vitae metus hendrerit "
+    "rhoncus ut et magna. Cras ac augue quis nibh pharetra sagittis. Donec ullamcorper vel eros semper pretium. Proin "
+    "vel sollicitudin eros. Nulla sollicitudin mattis turpis id suscipit. Aliquam sed risus velit. Aliquam iaculis nec "
+    "nibh ac egestas. Duis finibus semper est sed consequat. Sed in sapien quis nibh dignissim mattis. Vestibulum nec "
+    "metus sodales, euismod mauris ac, sollicitudin libero. Maecenas non arcu ac velit ullamcorper fringilla et quis "
+    "nulla. Curabitur posuere leo eget ipsum tincidunt dignissim. Cras ultricies suscipit neque, quis suscipit tortor "
+    "venenatis non. Cras nisl mi, bibendum in vulputate quis, vestibulum ornare enim. Nunc hendrerit placerat dui, "
+    "aliquam mollis sem convallis et. Integer vitae urna diam. Phasellus et imperdiet est. Maecenas auctor facilisis "
+    "nibh non commodo. Suspendisse iaculis quam id bibendum feugiat. Pellentesque felis erat, egestas a libero ac, "
+    "laoreet consectetur elit. Cras ut suscipit ex. Etiam gravida sem quis ex porta, eu lacinia tortor fermentum. "
+    "Nulla consequat odio enim, sed condimentum est sagittis a. Quisque nec commodo tellus. Phasellus elementum "
+    "feugiat dolor et feugiat. Praesent sed mattis tortor. In vitae sodales purus. Morbi accumsan, ligula et interdum "
+    "lacinia, leo risus suscipit urna, non luctus mi justo eu ipsum. Curabitur venenatis pretium orci id porttitor. "
+    "Quisque dapibus nisl sit amet elit lobortis sagittis. Orci varius natoque penatibus et magnis dis parturient "
+    "montes, nascetur ridiculus mus. Mauris varius dui sit amet tortor facilisis vestibulum. Curabitur condimentum "
+    "justo nec orci mattis auctor. Quisque aliquet condimentum arcu ac sollicitudin. Maecenas elit elit, condimentum "
+    "vitae auctor a, cursus et sem. Cras vehicula ante in consequat fermentum. Praesent at massa nisi. Mauris pretium "
+    "euismod eros, ut posuere ligula ullamcorper id. Nullam aliquam malesuada est at dignissim. Pellentesque finibus "
+    "sagittis libero nec bibendum. Phasellus dolor ipsum, finibus quis turpis quis, mollis interdum felis.";
+
+template <class T>
+void rc(benchmark::State& state) {
+    const std::vector<T> a(std::begin(src), std::end(src));
+    std::vector<T> b(std::size(src));
+
+    for (auto _ : state) {
+        std::replace_copy(std::begin(a), std::end(a), std::begin(b), T{'m'}, T{'w'});
+    }
+}
+
+template <class T>
+void rc_if(benchmark::State& state) {
+    const std::vector<T> a(std::begin(src), std::end(src));
+    std::vector<T> b(std::size(src));
+
+    for (auto _ : state) {
+        (void) std::replace_copy_if(
+            std::begin(a), std::end(a), std::begin(b), [](auto x) { return x <= T{'Z'}; }, T{'X'});
+    }
+}
+
+BENCHMARK(rc<std::uint8_t>);
+BENCHMARK(rc<std::uint16_t>);
+BENCHMARK(rc<std::uint32_t>);
+BENCHMARK(rc<std::uint64_t>);
+
+BENCHMARK(rc_if<std::uint8_t>);
+BENCHMARK(rc_if<std::uint16_t>);
+BENCHMARK(rc_if<std::uint32_t>);
+BENCHMARK(rc_if<std::uint64_t>);
+
+BENCHMARK_MAIN();
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 06152ed95db..e07dcb41f03 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -3843,6 +3843,15 @@ namespace ranges {
 } // namespace ranges
 #endif // _HAS_CXX20
 
+// TRANSITION, DevCom-10606350: help the compiler auto-vectorize for simple types
+template <class _UOutIt, class _InTy, class _NewTy, class _OutTy = remove_pointer_t<_UOutIt>>
+_INLINE_VAR constexpr bool _Can_vectorize_replace_copy = conjunction_v<is_pointer<_UOutIt>, is_same<_InTy, _NewTy>,
+    disjunction<
+#ifdef __cpp_lib_byte
+        conjunction<is_same<_InTy, byte>, is_same<_OutTy, byte>>,
+#endif // defined(__cpp_lib_byte)
+        conjunction<is_integral<_InTy>, is_integral<_OutTy>>, conjunction<is_pointer<_InTy>, is_pointer<_OutTy>>>>;
+
 _EXPORT_STD template <class _InIt, class _OutIt, class _Ty>
 _CONSTEXPR20 _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const _Ty& _Oldval, const _Ty& _Newval) {
     // copy replacing each matching _Oldval with _Newval
@@ -3851,10 +3860,14 @@ _CONSTEXPR20 _OutIt replace_copy(_InIt _First, _InIt _Last, _OutIt _Dest, const
     const auto _ULast = _STD _Get_unwrapped(_Last);
     auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
     for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
-        if (*_UFirst == _Oldval) {
-            *_UDest = _Newval;
+        if constexpr (_Can_vectorize_replace_copy<decltype(_UDest), _Iter_value_t<_InIt>, _Ty>) {
+            *_UDest = *_UFirst == _Oldval ? _Newval : *_UFirst;
         } else {
-            *_UDest = *_UFirst;
+            if (*_UFirst == _Oldval) {
+                *_UDest = _Newval;
+            } else {
+                *_UDest = *_UFirst;
+            }
         }
     }
 
@@ -3921,10 +3934,14 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<equal_to, projected<_It, _Pj>, const _Ty1*>);
 
             for (; _First != _Last; ++_First, (void) ++_Result) {
-                if (_STD invoke(_Proj, *_First) == _Oldval) {
-                    *_Result = _Newval;
+                if constexpr (_Can_vectorize_replace_copy<_Out, iter_value_t<_It>, _Ty2>) {
+                    *_Result = _STD invoke(_Proj, *_First) == _Oldval ? _Newval : *_First;
                 } else {
-                    *_Result = *_First;
+                    if (_STD invoke(_Proj, *_First) == _Oldval) {
+                        *_Result = _Newval;
+                    } else {
+                        *_Result = *_First;
+                    }
                 }
             }
 
@@ -3944,10 +3961,14 @@ _CONSTEXPR20 _OutIt replace_copy_if(_InIt _First, _InIt _Last, _OutIt _Dest, _Pr
     const auto _ULast = _STD _Get_unwrapped(_Last);
     auto _UDest       = _STD _Get_unwrapped_n(_Dest, _STD _Idl_distance<_InIt>(_UFirst, _ULast));
     for (; _UFirst != _ULast; ++_UFirst, (void) ++_UDest) {
-        if (_Pred(*_UFirst)) {
-            *_UDest = _Val;
+        if constexpr (_Can_vectorize_replace_copy<decltype(_UDest), _Iter_value_t<_InIt>, _Ty>) {
+            *_UDest = _Pred(*_UFirst) ? _Val : *_UFirst;
         } else {
-            *_UDest = *_UFirst;
+            if (_Pred(*_UFirst)) {
+                *_UDest = _Val;
+            } else {
+                *_UDest = *_UFirst;
+            }
         }
     }
 
@@ -4014,10 +4035,14 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(indirect_unary_predicate<_Pr, projected<_It, _Pj>>);
 
             for (; _First != _Last; ++_First, (void) ++_Result) {
-                if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
-                    *_Result = _Newval;
+                if constexpr (_Can_vectorize_replace_copy<_Out, iter_value_t<_It>, _Ty>) {
+                    *_Result = _STD invoke(_Pred, _STD invoke(_Proj, *_First)) ? _Newval : *_First;
                 } else {
-                    *_Result = *_First;
+                    if (_STD invoke(_Pred, _STD invoke(_Proj, *_First))) {
+                        *_Result = _Newval;
+                    } else {
+                        *_Result = *_First;
+                    }
                 }
             }
 

From 9d761bd5135e4e2b971de7f2884e458788f70d52 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 21 Mar 2024 23:48:51 +0200
Subject: [PATCH 08/45] Vectorize `find_first_of` for 8 and 16 bit elements
 with SSE4.2 `pcmpestri` (#4466)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/CMakeLists.txt                     |  1 +
 benchmarks/src/find_first_of.cpp              | 46 +++++++++++
 stl/inc/algorithm                             | 69 ++++++++++++++++
 stl/src/vector_algorithms.cpp                 | 78 ++++++++++++++++++
 .../VSO_0000000_vector_algorithms/test.cpp    | 81 +++++++++++++++++++
 5 files changed, 275 insertions(+)
 create mode 100644 benchmarks/src/find_first_of.cpp

diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index 498ddb90f4a..a45c736901d 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -110,6 +110,7 @@ endfunction()
 
 add_benchmark(bitset_to_string src/bitset_to_string.cpp)
 add_benchmark(find_and_count src/find_and_count.cpp)
+add_benchmark(find_first_of src/find_first_of.cpp)
 add_benchmark(locale_classic src/locale_classic.cpp)
 add_benchmark(minmax_element src/minmax_element.cpp)
 add_benchmark(path_lexically_normal src/path_lexically_normal.cpp)
diff --git a/benchmarks/src/find_first_of.cpp b/benchmarks/src/find_first_of.cpp
new file mode 100644
index 00000000000..170793f1e58
--- /dev/null
+++ b/benchmarks/src/find_first_of.cpp
@@ -0,0 +1,46 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <cstddef>
+#include <cstdint>
+#include <numeric>
+#include <vector>
+
+using namespace std;
+
+template <class T, size_t Pos, size_t NSize, size_t HSize = Pos * 2, size_t Which = 0>
+void bm(benchmark::State& state) {
+    vector<T> h(HSize, T{'.'});
+    vector<T> n(NSize);
+    iota(n.begin(), n.end(), T{'a'});
+
+    static_assert(Pos < HSize);
+    static_assert(Which < NSize);
+    h[Pos] = n[Which];
+
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(find_first_of(h.begin(), h.end(), n.begin(), n.end()));
+    }
+}
+
+BENCHMARK(bm<uint8_t, 2, 3>);
+BENCHMARK(bm<uint16_t, 2, 3>);
+
+BENCHMARK(bm<uint8_t, 7, 4>);
+BENCHMARK(bm<uint16_t, 7, 4>);
+
+BENCHMARK(bm<uint8_t, 9, 3>);
+BENCHMARK(bm<uint16_t, 9, 3>);
+
+BENCHMARK(bm<uint8_t, 22, 5>);
+BENCHMARK(bm<uint16_t, 22, 5>);
+
+BENCHMARK(bm<uint8_t, 3056, 7>);
+BENCHMARK(bm<uint16_t, 3056, 7>);
+
+BENCHMARK(bm<uint8_t, 1011, 11>);
+BENCHMARK(bm<uint16_t, 1011, 11>);
+
+BENCHMARK_MAIN();
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index e07dcb41f03..fd9882d74cd 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -58,6 +58,11 @@ const void* __stdcall __std_find_last_trivial_2(const void* _First, const void*
 const void* __stdcall __std_find_last_trivial_4(const void* _First, const void* _Last, uint32_t _Val) noexcept;
 const void* __stdcall __std_find_last_trivial_8(const void* _First, const void* _Last, uint64_t _Val) noexcept;
 
+const void* __stdcall __std_find_first_of_trivial_1(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+const void* __stdcall __std_find_first_of_trivial_2(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept;
+
 __declspec(noalias) _Min_max_1i __stdcall __std_minmax_1i(const void* _First, const void* _Last) noexcept;
 __declspec(noalias) _Min_max_1u __stdcall __std_minmax_1u(const void* _First, const void* _Last) noexcept;
 __declspec(noalias) _Min_max_2i __stdcall __std_minmax_2i(const void* _First, const void* _Last) noexcept;
@@ -160,6 +165,29 @@ _Ty* __std_find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _V
         static_assert(_Always_false<_Ty>, "Unexpected size");
     }
 }
+
+template <class _Ty1, class _Ty2>
+_Ty1* __std_find_first_of_trivial(
+    _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept {
+    if constexpr (sizeof(_Ty1) == 1) {
+        return const_cast<_Ty1*>(
+            static_cast<const _Ty1*>(::__std_find_first_of_trivial_1(_First1, _Last1, _First2, _Last2)));
+    } else if constexpr (sizeof(_Ty1) == 2) {
+        return const_cast<_Ty1*>(
+            static_cast<const _Ty1*>(::__std_find_first_of_trivial_2(_First1, _Last1, _First2, _Last2)));
+    } else {
+        static_assert(_Always_false<_Ty1>, "Unexpected size");
+    }
+}
+
+// find_first_of vectorization is likely to be a win after this size (in elements)
+_INLINE_VAR constexpr ptrdiff_t _Threshold_find_first_of = 16;
+
+// Can we activate the vector algorithms for find_first_of?
+template <class _It1, class _It2, class _Pr>
+_INLINE_VAR constexpr bool _Vector_alg_in_find_first_of_is_safe =
+    _Equal_memcmp_is_safe<_It1, _It2, _Pr> // can replace value comparison with bitwise comparison
+    && sizeof(_Iter_value_t<_It1>) <= 2; // pcmpestri compatible size
 _STD_END
 #endif // _USE_STD_VECTOR_ALGORITHMS
 
@@ -3321,6 +3349,24 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(
     const auto _ULast1  = _STD _Get_unwrapped(_Last1);
     const auto _UFirst2 = _STD _Get_unwrapped(_First2);
     const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Vector_alg_in_find_first_of_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+        if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) {
+            const auto _First1_ptr = _STD _To_address(_UFirst1);
+            const auto _Result     = _STD __std_find_first_of_trivial(
+                    _First1_ptr, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), _STD _To_address(_ULast2));
+
+            if constexpr (is_pointer_v<decltype(_UFirst1)>) {
+                _UFirst1 = _Result;
+            } else {
+                _UFirst1 += _Result - _First1_ptr;
+            }
+            _STD _Seek_wrapped(_First1, _UFirst1);
+            return _First1;
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
     for (; _UFirst1 != _ULast1; ++_UFirst1) {
         for (auto _UMid2 = _UFirst2; _UMid2 != _ULast2; ++_UMid2) {
             if (_Pred(*_UFirst1, *_UMid2)) {
@@ -3398,6 +3444,29 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
             _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
 
+#if _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (_Vector_alg_in_find_first_of_is_safe<_It1, _It2, _Pr> && sized_sentinel_for<_Se1, _It1>
+                          && sized_sentinel_for<_Se2, _It2> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) {
+                if (!_STD is_constant_evaluated() && _Last1 - _First1 >= _Threshold_find_first_of) {
+                    const auto _Count1     = _Last1 - _First1;
+                    const auto _First1_ptr = _STD _To_address(_First1);
+                    const auto _Last1_ptr  = _First1_ptr + _Count1;
+
+                    const auto _Count2     = _Last2 - _First2;
+                    const auto _First2_ptr = _STD _To_address(_First2);
+                    const auto _Last2_ptr  = _First2_ptr + _Count2;
+
+                    const auto _Result =
+                        _STD __std_find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr);
+
+                    if constexpr (is_pointer_v<_It1>) {
+                        return _Result;
+                    } else {
+                        return _First1 + (_Result - _First1_ptr);
+                    }
+                }
+            }
+#endif // _USE_STD_VECTOR_ALGORITHMS
             for (; _First1 != _Last1; ++_First1) {
                 for (auto _Mid2 = _First2; _Mid2 != _Last2; ++_Mid2) {
                     if (_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_Mid2))) {
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index d1e2b654e4a..176abaa94e4 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -2009,6 +2009,74 @@ namespace {
         }
         return _Result;
     }
+
+    template <class _Ty>
+    const void* __stdcall __std_find_first_of_trivial_impl(
+        const void* _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
+#ifndef _M_ARM64EC
+        const size_t _Needle_length = _Byte_length(_First2, _Last2);
+
+        if (_Use_sse42() && _Needle_length <= 16) {
+            constexpr int _Op =
+                (sizeof(_Ty) == 1 ? _SIDD_UBYTE_OPS : _SIDD_UWORD_OPS) | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT;
+            constexpr int _Part_size_el = sizeof(_Ty) == 1 ? 16 : 8;
+
+            const int _Needle_length_el = static_cast<int>(_Needle_length / sizeof(_Ty));
+
+            alignas(16) uint8_t _Tmp1[16];
+            memcpy(_Tmp1, _First2, _Needle_length);
+            const __m128i _Needle = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+
+            const size_t _Haystack_length = _Byte_length(_First1, _Last1);
+            const void* _Stop_at          = _First1;
+            _Advance_bytes(_Stop_at, _Haystack_length & ~size_t{0xF});
+
+            while (_First1 != _Stop_at) {
+                const __m128i _Haystack_part = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+
+                if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op)) {
+                    const int _Pos = _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op);
+                    _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                    return _First1;
+                }
+
+                _Advance_bytes(_First1, 16);
+            }
+
+            const size_t _Last_part_size = _Haystack_length & 0xF;
+            const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+
+            alignas(16) uint8_t _Tmp2[16];
+            memcpy(_Tmp2, _First1, _Last_part_size);
+            const __m128i _Haystack_last_part = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+
+            if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_last_part, _Last_part_size_el, _Op)) {
+                const int _Pos = _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_last_part, _Last_part_size_el, _Op);
+                _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                return _First1;
+            }
+
+            _Advance_bytes(_First1, _Last_part_size);
+            return _First1;
+        }
+#endif // !_M_ARM64EC
+
+        auto _Ptr_haystack           = static_cast<const _Ty*>(_First1);
+        const auto _Ptr_haystack_end = static_cast<const _Ty*>(_Last1);
+        const auto _Ptr_needle       = static_cast<const _Ty*>(_First2);
+        const auto _Ptr_needle_end   = static_cast<const _Ty*>(_Last2);
+
+        for (; _Ptr_haystack != _Ptr_haystack_end; ++_Ptr_haystack) {
+            for (auto _Ptr = _Ptr_needle; _Ptr != _Ptr_needle_end; ++_Ptr) {
+                if (*_Ptr_haystack == *_Ptr) {
+                    return _Ptr_haystack;
+                }
+            }
+        }
+
+        return _Ptr_haystack;
+    }
+
 } // unnamed namespace
 
 extern "C" {
@@ -2094,6 +2162,16 @@ __declspec(noalias) size_t
     return __std_count_trivial_impl<_Find_traits_8>(_First, _Last, _Val);
 }
 
+const void* __stdcall __std_find_first_of_trivial_1(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept {
+    return __std_find_first_of_trivial_impl<uint8_t>(_First1, _Last1, _First2, _Last2);
+}
+
+const void* __stdcall __std_find_first_of_trivial_2(
+    const void* _First1, const void* _Last1, const void* _First2, const void* _Last2) noexcept {
+    return __std_find_first_of_trivial_impl<uint16_t>(_First1, _Last1, _First2, _Last2);
+}
+
 } // extern "C"
 
 #ifndef _M_ARM64EC
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
index 510c7b99353..af4f710cddd 100644
--- a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
+++ b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
@@ -120,6 +120,18 @@ auto last_known_good_find_last(FwdIt first, FwdIt last, T v) {
     }
 }
 
+template <class FwdItH, class FwdItN>
+auto last_known_good_find_first_of(FwdItH h_first, FwdItH h_last, FwdItN n_first, FwdItN n_last) {
+    for (; h_first != h_last; ++h_first) {
+        for (FwdItN n = n_first; n != n_last; ++n) {
+            if (*h_first == *n) {
+                return h_first;
+            }
+        }
+    }
+    return h_first;
+}
+
 template <class T>
 void test_case_find(const vector<T>& input, T v) {
     auto expected = last_known_good_find(input.begin(), input.end(), v);
@@ -211,6 +223,57 @@ void test_find_last(mt19937_64& gen) {
 }
 #endif // _HAS_CXX23
 
+template <class T>
+void test_case_find_first_of(const vector<T>& input_haystack, const vector<T>& input_needle) {
+    auto expected = last_known_good_find_first_of(
+        input_haystack.begin(), input_haystack.end(), input_needle.begin(), input_needle.end());
+    auto actual = find_first_of(input_haystack.begin(), input_haystack.end(), input_needle.begin(), input_needle.end());
+    assert(expected == actual);
+#if _HAS_CXX20
+    auto ranges_actual = ranges::find_first_of(input_haystack, input_needle);
+    assert(expected == ranges_actual);
+#endif // _HAS_CXX20
+}
+
+template <class T>
+void test_find_first_of(mt19937_64& gen) {
+    constexpr size_t needleDataCount = 30;
+    using TD                         = conditional_t<sizeof(T) == 1, int, T>;
+    uniform_int_distribution<TD> dis('a', 'z');
+    vector<T> input_haystack;
+    vector<T> input_needle;
+    input_haystack.reserve(dataCount);
+    input_needle.reserve(needleDataCount);
+
+    for (;;) {
+        input_needle.clear();
+
+        test_case_find_first_of(input_haystack, input_needle);
+        for (size_t attempts = 0; attempts < needleDataCount; ++attempts) {
+            input_needle.push_back(static_cast<T>(dis(gen)));
+            test_case_find_first_of(input_haystack, input_needle);
+        }
+
+        if (input_haystack.size() == dataCount) {
+            break;
+        }
+
+        input_haystack.push_back(static_cast<T>(dis(gen)));
+    }
+}
+
+template <class C1, class C2>
+void test_find_first_of_containers() {
+    C1 haystack{'m', 'e', 'o', 'w', 'C', 'A', 'T', 'S'};
+    C2 needle{'R', 'S', 'T'};
+    const auto result = find_first_of(haystack.begin(), haystack.end(), needle.begin(), needle.end());
+    assert(result == haystack.begin() + 6);
+#if _HAS_CXX20
+    const auto ranges_result = ranges::find_first_of(haystack, needle);
+    assert(ranges_result == haystack.begin() + 6);
+#endif // _HAS_CXX20
+}
+
 template <class T>
 void test_min_max_element(mt19937_64& gen) {
     using Limits = numeric_limits<T>;
@@ -437,6 +500,24 @@ void test_vector_algorithms(mt19937_64& gen) {
     test_find_last<unsigned long long>(gen);
 #endif // _HAS_CXX23
 
+    test_find_first_of<char>(gen);
+    test_find_first_of<signed char>(gen);
+    test_find_first_of<unsigned char>(gen);
+    test_find_first_of<short>(gen);
+    test_find_first_of<unsigned short>(gen);
+    test_find_first_of<int>(gen);
+    test_find_first_of<unsigned int>(gen);
+    test_find_first_of<long long>(gen);
+    test_find_first_of<unsigned long long>(gen);
+
+    test_find_first_of_containers<vector<char>, vector<signed char>>();
+    test_find_first_of_containers<vector<char>, vector<unsigned char>>();
+    test_find_first_of_containers<vector<wchar_t>, vector<char>>();
+    test_find_first_of_containers<const vector<char>, const vector<char>>();
+    test_find_first_of_containers<vector<char>, const vector<char>>();
+    test_find_first_of_containers<const vector<wchar_t>, vector<wchar_t>>();
+    test_find_first_of_containers<vector<char>, vector<int>>();
+
     test_min_max_element<char>(gen);
     test_min_max_element<signed char>(gen);
     test_min_max_element<unsigned char>(gen);

From 15bccea3f410e468ef164a13b2c92d796ec92ba0 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 21 Mar 2024 23:52:40 +0200
Subject: [PATCH 09/45] `vector_algorithms.cpp`: clearer control flow in
 `bitset::to_string` (#4490)

---
 stl/src/vector_algorithms.cpp | 34 ++++++++++++++--------------------
 1 file changed, 14 insertions(+), 20 deletions(-)

diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index 176abaa94e4..ead6d699cff 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -2254,10 +2254,7 @@ __declspec(noalias) void __stdcall __std_bitset_to_string_1(
         }
 
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
-        return;
-    }
-
-    if (_Use_sse2()) {
+    } else if (_Use_sse2()) {
         const __m128i _Px0 = _mm_set1_epi8(_Elem0 ^ _Elem1);
         const __m128i _Px1 = _mm_set1_epi8(_Elem1);
         if (_Size_bits >= 16) {
@@ -2290,13 +2287,13 @@ __declspec(noalias) void __stdcall __std_bitset_to_string_1(
                 _Dest[_Ix] = _Tmpd[_Ix];
             }
         }
-
-        return;
-    }
+    } else
 #endif // !defined(_M_ARM64EC)
-    const auto _Arr = reinterpret_cast<const uint8_t*>(_Src);
-    for (size_t _Ix = 0; _Ix < _Size_bits; ++_Ix) {
-        _Dest[_Size_bits - 1 - _Ix] = ((_Arr[_Ix >> 3] >> (_Ix & 7)) & 1) != 0 ? _Elem1 : _Elem0;
+    {
+        const auto _Arr = reinterpret_cast<const uint8_t*>(_Src);
+        for (size_t _Ix = 0; _Ix < _Size_bits; ++_Ix) {
+            _Dest[_Size_bits - 1 - _Ix] = ((_Arr[_Ix >> 3] >> (_Ix & 7)) & 1) != 0 ? _Elem1 : _Elem0;
+        }
     }
 }
 
@@ -2337,10 +2334,7 @@ __declspec(noalias) void __stdcall __std_bitset_to_string_2(
         }
 
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
-        return;
-    }
-
-    if (_Use_sse2()) {
+    } else if (_Use_sse2()) {
         const __m128i _Px0 = _mm_set1_epi16(_Elem0 ^ _Elem1);
         const __m128i _Px1 = _mm_set1_epi16(_Elem1);
         if (_Size_bits >= 8) {
@@ -2367,13 +2361,13 @@ __declspec(noalias) void __stdcall __std_bitset_to_string_2(
                 _Dest[_Ix] = _Tmpd[_Ix];
             }
         }
-
-        return;
-    }
+    } else
 #endif // !defined(_M_ARM64EC)
-    const auto _Arr = reinterpret_cast<const uint8_t*>(_Src);
-    for (size_t _Ix = 0; _Ix < _Size_bits; ++_Ix) {
-        _Dest[_Size_bits - 1 - _Ix] = ((_Arr[_Ix >> 3] >> (_Ix & 7)) & 1) != 0 ? _Elem1 : _Elem0;
+    {
+        const auto _Arr = reinterpret_cast<const uint8_t*>(_Src);
+        for (size_t _Ix = 0; _Ix < _Size_bits; ++_Ix) {
+            _Dest[_Size_bits - 1 - _Ix] = ((_Arr[_Ix >> 3] >> (_Ix & 7)) & 1) != 0 ? _Elem1 : _Elem0;
+        }
     }
 }
 

From 47825be0c7288ac3379734c83c576b09f0ee33fa Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 21 Mar 2024 14:54:13 -0700
Subject: [PATCH 10/45] libcxx `stol.pass.cpp` is now passing for ASAN (#4492)

---
 tests/libcxx/expected_results.txt | 3 ---
 1 file changed, 3 deletions(-)

diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 3f43c87b132..69cabaff366 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -209,9 +209,6 @@ std/language.support/support.dynamic/new.delete/new.delete.array/new.size_nothro
 std/language.support/support.dynamic/new.delete/new.delete.single/new.size_align_nothrow.pass.cpp:1 FAIL
 std/language.support/support.dynamic/new.delete/new.delete.single/new.size_nothrow.pass.cpp:1 FAIL
 
-# ASAN runtime intercepts `strtol` and breaks LWG-2009 (VSO-1875597)
-std/strings/string.conversions/stol.pass.cpp:1 FAIL
-
 # Not analyzed. SKIPPED because this is x86-specific.
 # ERROR: AddressSanitizer: allocator is out of memory trying to allocate NNNN bytes
 std/atomics/atomics.types.generic/atomics.types.float/compare_exchange_strong.pass.cpp:1 SKIPPED

From 8e2d724cc1072b4052b14d8c5f81a830b8f1d8cb Mon Sep 17 00:00:00 2001
From: Ecrin <ecrin_3@hotmail.com>
Date: Fri, 22 Mar 2024 00:56:47 +0300
Subject: [PATCH 11/45] Add binary flag to xiosbase class to correct place
 (#4493)

---
 stl/inc/xiosbase | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/xiosbase b/stl/inc/xiosbase
index af192b61692..3d19d5969a2 100644
--- a/stl/inc/xiosbase
+++ b/stl/inc/xiosbase
@@ -61,9 +61,9 @@ public:
     static constexpr int ate        = 0x04;
     static constexpr int app        = 0x08;
     static constexpr int trunc      = 0x10;
+    static constexpr int binary     = 0x20;
     static constexpr int _Nocreate  = 0x40;
     static constexpr int _Noreplace = 0x80;
-    static constexpr int binary     = 0x20;
 #if _HAS_CXX23
     static constexpr int noreplace = _Noreplace;
 #endif

From ffd735ac1aacc9623fefc885be66fd9dce1ce310 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Thu, 28 Mar 2024 18:35:20 +0200
Subject: [PATCH 12/45] `mismatch` vectorization (#4495)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/CMakeLists.txt                     |   1 +
 benchmarks/src/mismatch.cpp                   |  36 ++++
 stl/inc/algorithm                             |  34 ++++
 stl/inc/xutility                              |  35 ++++
 stl/src/vector_algorithms.cpp                 |  99 ++++++++++
 .../VSO_0000000_vector_algorithms/test.cpp    | 183 ++++++++++++++++++
 6 files changed, 388 insertions(+)
 create mode 100644 benchmarks/src/mismatch.cpp

diff --git a/benchmarks/CMakeLists.txt b/benchmarks/CMakeLists.txt
index a45c736901d..0f22a1f003e 100644
--- a/benchmarks/CMakeLists.txt
+++ b/benchmarks/CMakeLists.txt
@@ -113,6 +113,7 @@ add_benchmark(find_and_count src/find_and_count.cpp)
 add_benchmark(find_first_of src/find_first_of.cpp)
 add_benchmark(locale_classic src/locale_classic.cpp)
 add_benchmark(minmax_element src/minmax_element.cpp)
+add_benchmark(mismatch src/mismatch.cpp)
 add_benchmark(path_lexically_normal src/path_lexically_normal.cpp)
 add_benchmark(priority_queue_push_range src/priority_queue_push_range.cpp)
 add_benchmark(random_integer_generation src/random_integer_generation.cpp)
diff --git a/benchmarks/src/mismatch.cpp b/benchmarks/src/mismatch.cpp
new file mode 100644
index 00000000000..f6a3069ac22
--- /dev/null
+++ b/benchmarks/src/mismatch.cpp
@@ -0,0 +1,36 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <algorithm>
+#include <benchmark/benchmark.h>
+#include <cstddef>
+#include <cstdint>
+#include <ranges>
+#include <vector>
+
+using namespace std;
+
+constexpr int64_t no_pos = -1;
+
+template <class T>
+void bm(benchmark::State& state) {
+    vector<T> a(static_cast<size_t>(state.range(0)), T{'.'});
+    vector<T> b(static_cast<size_t>(state.range(0)), T{'.'});
+
+    if (state.range(1) != no_pos) {
+        b.at(static_cast<size_t>(state.range(1))) = 'x';
+    }
+
+    for (auto _ : state) {
+        benchmark::DoNotOptimize(ranges::mismatch(a, b));
+    }
+}
+
+#define COMMON_ARGS Args({8, 3})->Args({24, 22})->Args({105, -1})->Args({4021, 3056})
+
+BENCHMARK(bm<uint8_t>)->COMMON_ARGS;
+BENCHMARK(bm<uint16_t>)->COMMON_ARGS;
+BENCHMARK(bm<uint32_t>)->COMMON_ARGS;
+BENCHMARK(bm<uint64_t>)->COMMON_ARGS;
+
+BENCHMARK_MAIN();
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index fd9882d74cd..ff1f8b65e3c 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -669,6 +669,23 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI
     auto _UFirst1      = _STD _Get_unwrapped(_First1);
     const auto _ULast1 = _STD _Get_unwrapped(_Last1);
     auto _UFirst2      = _STD _Get_unwrapped_n(_First2, _STD _Idl_distance<_InIt1>(_UFirst1, _ULast1));
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+        if (!_STD _Is_constant_evaluated()) {
+            constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>);
+
+            const size_t _Pos = _STD __std_mismatch<_Elem_size>(
+                _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast<size_t>(_ULast1 - _UFirst1));
+
+            _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos);
+            _UFirst2 += static_cast<_Iter_diff_t<_InIt2>>(_Pos);
+
+            _STD _Seek_wrapped(_First2, _UFirst2);
+            _STD _Seek_wrapped(_First1, _UFirst1);
+            return {_First1, _First2};
+        }
+    }
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
     while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) {
         ++_UFirst1;
         ++_UFirst2;
@@ -716,6 +733,23 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(
         const _CT _Count2 = _ULast2 - _UFirst2;
         const auto _Count = static_cast<_Iter_diff_t<_InIt1>>((_STD min)(_Count1, _Count2));
         _ULast1           = _UFirst1 + _Count;
+#if _USE_STD_VECTOR_ALGORITHMS
+        if constexpr (_Equal_memcmp_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
+            if (!_STD _Is_constant_evaluated()) {
+                constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>);
+
+                const size_t _Pos = _STD __std_mismatch<_Elem_size>(
+                    _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast<size_t>(_Count));
+
+                _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos);
+                _UFirst2 += static_cast<_Iter_diff_t<_InIt2>>(_Pos);
+
+                _STD _Seek_wrapped(_First2, _UFirst2);
+                _STD _Seek_wrapped(_First1, _UFirst1);
+                return {_First1, _First2};
+            }
+        }
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
         while (_UFirst1 != _ULast1 && _Pred(*_UFirst1, *_UFirst2)) {
             ++_UFirst1;
             ++_UFirst2;
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 260c44f211f..f2e0482894a 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -124,6 +124,11 @@ __declspec(noalias) int64_t __stdcall __std_max_8i(const void* _First, const voi
 __declspec(noalias) uint64_t __stdcall __std_max_8u(const void* _First, const void* _Last) noexcept;
 __declspec(noalias) float __stdcall __std_max_f(const void* _First, const void* _Last) noexcept;
 __declspec(noalias) double __stdcall __std_max_d(const void* _First, const void* _Last) noexcept;
+
+__declspec(noalias) size_t __stdcall __std_mismatch_1(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_2(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_4(const void* _First1, const void* _First2, size_t _Count) noexcept;
+__declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const void* _First2, size_t _Count) noexcept;
 } // extern "C"
 
 _STD_BEGIN
@@ -292,6 +297,22 @@ auto __std_max(_Ty* const _First, _Ty* const _Last) noexcept {
         static_assert(_Always_false<_Ty>, "Unexpected size");
     }
 }
+
+template <size_t _Element_size>
+inline size_t // TRANSITION, GH-4496
+    __std_mismatch(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    if constexpr (_Element_size == 1) {
+        return __std_mismatch_1(_First1, _First2, _Count);
+    } else if constexpr (_Element_size == 2) {
+        return __std_mismatch_2(_First1, _First2, _Count);
+    } else if constexpr (_Element_size == 4) {
+        return __std_mismatch_4(_First1, _First2, _Count);
+    } else if constexpr (_Element_size == 8) {
+        return __std_mismatch_8(_First1, _First2, _Count);
+    } else {
+        static_assert(_Always_false<integral_constant<size_t, _Element_size>>, "Unexpected size");
+    }
+}
 _STD_END
 
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -5477,6 +5498,20 @@ namespace ranges {
     _NODISCARD constexpr mismatch_result<_It1, _It2> _Mismatch_n(
         _It1 _First1, _It2 _First2, iter_difference_t<_It1> _Count, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
         _STL_INTERNAL_CHECK(_Count >= 0);
+#if _USE_STD_VECTOR_ALGORITHMS
+        if constexpr (_Equal_memcmp_is_safe<_It1, _It2, _Pr> && is_same_v<_Pj1, identity>
+                      && is_same_v<_Pj2, identity>) {
+            if (!_STD is_constant_evaluated()) {
+                constexpr size_t _Elem_size = sizeof(iter_value_t<_It1>);
+
+                const size_t _Pos = _STD __std_mismatch<_Elem_size>(
+                    _STD _To_address(_First1), _STD _To_address(_First2), static_cast<size_t>(_Count));
+
+                return {_First1 + static_cast<iter_difference_t<_It1>>(_Pos),
+                    _First2 + static_cast<iter_difference_t<_It2>>(_Pos)};
+            }
+        }
+#endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
         for (; _Count != 0; ++_First1, (void) ++_First2, --_Count) {
             if (!_STD invoke(_Pred, _STD invoke(_Proj1, *_First1), _STD invoke(_Proj2, *_First2))) {
                 break;
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index ead6d699cff..a5a637695e6 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -88,6 +88,12 @@ namespace {
     void _Advance_bytes(const void*& _Target, _Integral _Offset) noexcept {
         _Target = static_cast<const unsigned char*>(_Target) + _Offset;
     }
+
+    __m256i _Avx2_tail_mask_32(const size_t _Count_in_dwords) noexcept {
+        // _Count_in_dwords must be within [1, 7].
+        static constexpr unsigned int _Tail_masks[14] = {~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0, 0, 0, 0};
+        return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Tail_masks + (7 - _Count_in_dwords)));
+    }
 } // unnamed namespace
 
 extern "C" {
@@ -2077,6 +2083,79 @@ namespace {
         return _Ptr_haystack;
     }
 
+
+    template <class _Traits, class _Ty>
+    __declspec(noalias) size_t __stdcall __std_mismatch_impl(
+        const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+        size_t _Result = 0;
+#ifndef _M_ARM64EC
+        const auto _First1_ch = static_cast<const char*>(_First1);
+        const auto _First2_ch = static_cast<const char*>(_First2);
+
+        if (_Use_avx2()) {
+            const size_t _Count_bytes          = _Count * sizeof(_Ty);
+            const size_t _Count_bytes_avx_full = _Count_bytes & ~size_t{0x1F};
+
+            for (; _Result != _Count_bytes_avx_full; _Result += 0x20) {
+                const __m256i _Elem1 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First1_ch + _Result));
+                const __m256i _Elem2 = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First2_ch + _Result));
+                const auto _Bingo = ~static_cast<unsigned int>(_mm256_movemask_epi8(_Traits::_Cmp_avx(_Elem1, _Elem2)));
+                if (_Bingo != 0) {
+                    return (_Result + _tzcnt_u32(_Bingo)) / sizeof(_Ty);
+                }
+            }
+
+            const size_t _Count_tail = _Count_bytes & size_t{0x1C};
+
+            if (_Count_tail != 0) {
+                const __m256i _Tail_mask = _Avx2_tail_mask_32(_Count_tail >> 2);
+                const __m256i _Elem1 =
+                    _mm256_maskload_epi32(reinterpret_cast<const int*>(_First1_ch + _Result), _Tail_mask);
+                const __m256i _Elem2 =
+                    _mm256_maskload_epi32(reinterpret_cast<const int*>(_First2_ch + _Result), _Tail_mask);
+
+                const auto _Bingo = ~static_cast<unsigned int>(_mm256_movemask_epi8(_Traits::_Cmp_avx(_Elem1, _Elem2)));
+                if (_Bingo != 0) {
+                    return (_Result + _tzcnt_u32(_Bingo)) / sizeof(_Ty);
+                }
+
+                _Result += _Count_tail;
+            }
+
+            _Result /= sizeof(_Ty);
+
+            if constexpr (sizeof(_Ty) >= 4) {
+                return _Result;
+            }
+        } else if (_Traits::_Sse_available()) {
+            const size_t _Count_bytes_sse = (_Count * sizeof(_Ty)) & ~size_t{0xF};
+
+            for (; _Result != _Count_bytes_sse; _Result += 0x10) {
+                const __m128i _Elem1 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First1_ch + _Result));
+                const __m128i _Elem2 = _mm_loadu_si128(reinterpret_cast<const __m128i*>(_First2_ch + _Result));
+                const auto _Bingo =
+                    static_cast<unsigned int>(_mm_movemask_epi8(_Traits::_Cmp_sse(_Elem1, _Elem2))) ^ 0xFFFF;
+                if (_Bingo != 0) {
+                    unsigned long _Offset;
+                    _BitScanForward(&_Offset, _Bingo); // lgtm [cpp/conditionallyuninitializedvariable]
+                    return (_Result + _Offset) / sizeof(_Ty);
+                }
+            }
+
+            _Result /= sizeof(_Ty);
+        }
+#endif // !defined(_M_ARM64EC)
+        const auto _First1_el = static_cast<const _Ty*>(_First1);
+        const auto _First2_el = static_cast<const _Ty*>(_First2);
+
+        for (; _Result != _Count; ++_Result) {
+            if (_First1_el[_Result] != _First2_el[_Result]) {
+                break;
+            }
+        }
+
+        return _Result;
+    }
 } // unnamed namespace
 
 extern "C" {
@@ -2172,6 +2251,26 @@ const void* __stdcall __std_find_first_of_trivial_2(
     return __std_find_first_of_trivial_impl<uint16_t>(_First1, _Last1, _First2, _Last2);
 }
 
+__declspec(noalias) size_t
+    __stdcall __std_mismatch_1(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return __std_mismatch_impl<_Find_traits_1, uint8_t>(_First1, _First2, _Count);
+}
+
+__declspec(noalias) size_t
+    __stdcall __std_mismatch_2(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return __std_mismatch_impl<_Find_traits_2, uint16_t>(_First1, _First2, _Count);
+}
+
+__declspec(noalias) size_t
+    __stdcall __std_mismatch_4(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return __std_mismatch_impl<_Find_traits_4, uint32_t>(_First1, _First2, _Count);
+}
+
+__declspec(noalias) size_t
+    __stdcall __std_mismatch_8(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    return __std_mismatch_impl<_Find_traits_8, uint64_t>(_First1, _First2, _Count);
+}
+
 } // extern "C"
 
 #ifndef _M_ARM64EC
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
index af4f710cddd..e263e59d628 100644
--- a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
+++ b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
@@ -7,6 +7,7 @@
 #include <cstddef>
 #include <cstdint>
 #include <cstdio>
+#include <cstdlib>
 #include <deque>
 #include <functional>
 #include <isa_availability.h>
@@ -376,6 +377,165 @@ void test_min_max_element_special_cases() {
            == v.begin() + 2 * block_size_in_elements + last_vector_first_elem + 9);
 }
 
+template <class FwdIt>
+auto last_known_good_mismatch(FwdIt first1, FwdIt last1, FwdIt first2, FwdIt last2) {
+    for (; first1 != last1 && first2 != last2; ++first1, ++first2) {
+        if (*first1 != *first2) {
+            break;
+        }
+    }
+
+    return make_pair(first1, first2);
+}
+
+template <class T>
+void test_case_mismatch(const vector<T>& a, const vector<T>& b) {
+    auto expected = last_known_good_mismatch(a.begin(), a.end(), b.begin(), b.end());
+    auto actual   = mismatch(a.begin(), a.end(), b.begin(), b.end());
+    assert(expected == actual);
+#if _HAS_CXX20
+    auto ranges_actual = ranges::mismatch(a, b);
+    assert(get<0>(expected) == ranges_actual.in1);
+    assert(get<1>(expected) == ranges_actual.in2);
+#endif // _HAS_CXX20
+}
+
+template <class T>
+void test_mismatch(mt19937_64& gen) {
+    constexpr size_t shrinkCount   = 4;
+    constexpr size_t mismatchCount = 30;
+    using TD                       = conditional_t<sizeof(T) == 1, int, T>;
+    uniform_int_distribution<TD> dis('a', 'z');
+    vector<T> input_a;
+    vector<T> input_b;
+    input_a.reserve(dataCount);
+    input_b.reserve(dataCount);
+
+    for (;;) {
+        // equal
+        test_case_mismatch(input_a, input_b);
+
+        // different sizes
+        for (size_t i = 0; i != shrinkCount && !input_b.empty(); ++i) {
+            test_case_mismatch(input_a, input_b);
+            test_case_mismatch(input_b, input_a);
+            input_b.pop_back();
+        }
+
+        // actual mismatch (or maybe not, depending on random)
+        if (!input_b.empty()) {
+            uniform_int_distribution<size_t> mismatch_dis(0, input_a.size() - 1);
+
+            for (size_t attempts = 0; attempts < mismatchCount; ++attempts) {
+                const size_t possible_mismatch_pos = mismatch_dis(gen);
+                input_a[possible_mismatch_pos]     = static_cast<T>(dis(gen));
+                test_case_mismatch(input_a, input_b);
+                test_case_mismatch(input_b, input_a);
+            }
+        }
+
+        if (input_a.size() == dataCount) {
+            break;
+        }
+
+        input_a.push_back(static_cast<T>(dis(gen)));
+        input_b = input_a;
+    }
+}
+
+template <class C1, class C2>
+void test_mismatch_containers() {
+    C1 a{'m', 'e', 'o', 'w', ' ', 'C', 'A', 'T', 'S'};
+    C2 b{'m', 'e', 'o', 'w', ' ', 'K', 'I', 'T', 'T', 'E', 'N', 'S'};
+    const auto result_4 = mismatch(a.begin(), a.end(), b.begin(), b.end());
+    const auto result_3 = mismatch(a.begin(), a.end(), b.begin());
+    assert(get<0>(result_4) == a.begin() + 5);
+    assert(get<1>(result_4) == b.begin() + 5);
+    assert(get<0>(result_3) == a.begin() + 5);
+    assert(get<1>(result_3) == b.begin() + 5);
+#if _HAS_CXX20
+    const auto result_r = ranges::mismatch(a, b);
+    assert(result_r.in1 == a.begin() + 5);
+    assert(result_r.in2 == b.begin() + 5);
+#endif // _HAS_CXX20
+}
+
+namespace test_mismatch_sizes_and_alignments {
+    constexpr size_t range     = 33;
+    constexpr size_t alignment = 32;
+
+#pragma pack(push, 1)
+    template <class T, size_t Size, size_t PadSize>
+    struct with_pad {
+        char p[PadSize];
+        T v[Size];
+    };
+#pragma pack(pop)
+
+    template <class T, size_t Size, size_t PadSize>
+    char stack_array_various_alignments_impl() {
+        with_pad<T, Size + 1, PadSize + 1> a = {};
+        with_pad<T, Size + 1, PadSize + 1> b = {};
+        assert(mismatch(begin(a.v), end(a.v), begin(b.v), end(b.v)) == make_pair(end(a.v), end(b.v)));
+        return 0;
+    }
+
+    template <class T, size_t Size, size_t... PadSizes>
+    void stack_array_various_alignments(index_sequence<PadSizes...>) {
+        char ignored[] = {stack_array_various_alignments_impl<T, Size, PadSizes>()...};
+        (void) ignored;
+    }
+
+    template <class T, size_t Size>
+    char stack_array_impl() {
+        T a[Size + 1] = {};
+        T b[Size + 1] = {};
+        assert(mismatch(begin(a), end(a), begin(b), end(b)) == make_pair(end(a), end(b)));
+        stack_array_various_alignments<T, Size>(make_index_sequence<alignment>{});
+        return 0;
+    }
+
+    template <class T, size_t... Sizes>
+    void stack_array(index_sequence<Sizes...>) {
+        char ignored[] = {stack_array_impl<T, Sizes>()...};
+        (void) ignored;
+    }
+
+    template <class T>
+    void test() {
+        // stack with different sizes and alignments. ASan would catch out-of-range reads
+        stack_array<T>(make_index_sequence<range>{});
+
+        // vector with different sizes. ASan vector annotations would catch out-of-range reads
+        for (size_t i = 0; i != range; ++i) {
+            vector<T> a(i, 0);
+            vector<T> b(i, 0);
+            assert(mismatch(begin(a), end(a), begin(b), end(b)) == make_pair(end(a), end(b)));
+        }
+
+        // heap with different sizes. ASan would catch out-of-range reads
+        for (size_t i = 0; i != range; ++i) {
+            T* a = static_cast<T*>(calloc(i, sizeof(T)));
+            T* b = static_cast<T*>(calloc(i, sizeof(T)));
+            assert(mismatch(a, a + i, b, b + i) == make_pair(a + i, b + i));
+            free(a);
+            free(b);
+        }
+
+        // subarray from stack array. We would have wrong results if we run out of the range.
+        T a[range + 1] = {};
+        T b[range + 1] = {};
+        for (size_t i = 0; i != range; ++i) {
+            a[i + 1] = 1;
+            // whole range mismatch finds mismatch after past-the-end of the subarray
+            assert(mismatch(a, a + range + 1, b, b + range + 1) == make_pair(a + i + 1, b + i + 1));
+            // limited range mismatch gets to past-the-end of the subarray
+            assert(mismatch(a, a + i, b, b + i) == make_pair(a + i, b + i));
+            a[i + 1] = 0;
+        }
+    }
+} // namespace test_mismatch_sizes_and_alignments
+
 template <class BidIt>
 void last_known_good_reverse(BidIt first, BidIt last) {
     for (; first != last && first != --last; ++first) {
@@ -545,6 +705,29 @@ void test_vector_algorithms(mt19937_64& gen) {
     test_case_min_max_element(
         vector<int64_t>{-6604286336755016904, -4365366089374418225, 6104371530830675888, -8582621853879131834});
 
+    test_mismatch<char>(gen);
+    test_mismatch<signed char>(gen);
+    test_mismatch<unsigned char>(gen);
+    test_mismatch<short>(gen);
+    test_mismatch<unsigned short>(gen);
+    test_mismatch<int>(gen);
+    test_mismatch<unsigned int>(gen);
+    test_mismatch<long long>(gen);
+    test_mismatch<unsigned long long>(gen);
+
+    test_mismatch_containers<vector<char>, vector<signed char>>();
+    test_mismatch_containers<vector<char>, vector<unsigned char>>();
+    test_mismatch_containers<vector<wchar_t>, vector<char>>();
+    test_mismatch_containers<const vector<char>, const vector<char>>();
+    test_mismatch_containers<vector<char>, const vector<char>>();
+    test_mismatch_containers<const vector<wchar_t>, vector<wchar_t>>();
+    test_mismatch_containers<vector<char>, vector<int>>();
+
+    test_mismatch_sizes_and_alignments::test<char>();
+    test_mismatch_sizes_and_alignments::test<short>();
+    test_mismatch_sizes_and_alignments::test<int>();
+    test_mismatch_sizes_and_alignments::test<long long>();
+
     test_reverse<char>(gen);
     test_reverse<signed char>(gen);
     test_reverse<unsigned char>(gen);

From e0a75b3537d0b5a5afecee85e3a767ac5acf6650 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 29 Mar 2024 01:21:31 +0800
Subject: [PATCH 13/45] Implement LWG-3950 `std::basic_string_view` comparison
 operators are overspecified (#4510)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/xstring                              | 66 +++++++++---------
 tests/std/tests/P0220R1_string_view/test.cpp | 73 ++++++++++++++++++++
 2 files changed, 104 insertions(+), 35 deletions(-)

diff --git a/stl/inc/xstring b/stl/inc/xstring
index 55834e972ad..3b8a62ba6b8 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -1643,27 +1643,53 @@ namespace ranges {
 } // namespace ranges
 #endif // _HAS_CXX20
 
+#if _HAS_CXX20
+_EXPORT_STD template <class _Elem, class _Traits>
+_NODISCARD constexpr bool operator==(const basic_string_view<_Elem, _Traits> _Lhs,
+    const type_identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return _Lhs._Equal(_Rhs);
+}
+
+template <class _Traits, class = void>
+struct _Get_comparison_category {
+    using type = weak_ordering;
+};
+
+template <class _Traits>
+struct _Get_comparison_category<_Traits, void_t<typename _Traits::comparison_category>> {
+    using type = _Traits::comparison_category;
+
+    static_assert(_Is_any_of_v<type, partial_ordering, weak_ordering, strong_ordering>,
+        "N4971 [string.view.comparison]/4: Mandates: R denotes a comparison category type.");
+};
+
+template <class _Traits>
+using _Get_comparison_category_t = _Get_comparison_category<_Traits>::type;
+
 _EXPORT_STD template <class _Elem, class _Traits>
+_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(const basic_string_view<_Elem, _Traits> _Lhs,
+    const type_identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
+    return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
+}
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Elem, class _Traits>
 _NODISCARD constexpr bool operator==(
     const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
     return _Lhs._Equal(_Rhs);
 }
 
-#if !_HAS_CXX20
 template <class _Elem, class _Traits, int = 1> // TRANSITION, VSO-409326
 _NODISCARD constexpr bool operator==(
     const _Identity_t<basic_string_view<_Elem, _Traits>> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
     return _Lhs._Equal(_Rhs);
 }
-#endif // !_HAS_CXX20
 
-_EXPORT_STD template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
+template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
 _NODISCARD constexpr bool operator==(
     const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
     return _Lhs._Equal(_Rhs);
 }
 
-#if !_HAS_CXX20
 template <class _Elem, class _Traits>
 _NODISCARD constexpr bool operator!=(
     const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
@@ -1753,37 +1779,7 @@ _NODISCARD constexpr bool operator>=(
     const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
     return _Lhs.compare(_Rhs) >= 0;
 }
-#endif // !_HAS_CXX20
-
-#if _HAS_CXX20
-template <class _Traits, class = void>
-struct _Get_comparison_category {
-    using type = weak_ordering;
-};
-
-template <class _Traits>
-struct _Get_comparison_category<_Traits, void_t<typename _Traits::comparison_category>> {
-    using type = _Traits::comparison_category;
-
-    static_assert(_Is_any_of_v<type, partial_ordering, weak_ordering, strong_ordering>,
-        "N4950 [string.view.comparison]/4: Mandates: R denotes a comparison category type.");
-};
-
-template <class _Traits>
-using _Get_comparison_category_t = _Get_comparison_category<_Traits>::type;
-
-_EXPORT_STD template <class _Elem, class _Traits>
-_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
-    const basic_string_view<_Elem, _Traits> _Lhs, const basic_string_view<_Elem, _Traits> _Rhs) noexcept {
-    return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
-}
-
-_EXPORT_STD template <class _Elem, class _Traits, int = 2> // TRANSITION, VSO-409326
-_NODISCARD constexpr _Get_comparison_category_t<_Traits> operator<=>(
-    const basic_string_view<_Elem, _Traits> _Lhs, const _Identity_t<basic_string_view<_Elem, _Traits>> _Rhs) noexcept {
-    return static_cast<_Get_comparison_category_t<_Traits>>(_Lhs.compare(_Rhs) <=> 0);
-}
-#endif // _HAS_CXX20
+#endif // ^^^ !_HAS_CXX20 ^^^
 
 _EXPORT_STD using string_view = basic_string_view<char>;
 #ifdef __cpp_lib_char8_t
diff --git a/tests/std/tests/P0220R1_string_view/test.cpp b/tests/std/tests/P0220R1_string_view/test.cpp
index f6db52ddb21..a03ff3a220d 100644
--- a/tests/std/tests/P0220R1_string_view/test.cpp
+++ b/tests/std/tests/P0220R1_string_view/test.cpp
@@ -1261,6 +1261,79 @@ void test_C6510_warning() { // compile-only
     (void) sv;
 }
 
+#if _HAS_CXX20
+// LWG-3950 "std::basic_string_view comparison operators are overspecified"
+namespace test_lwg_3950 {
+    template <class Traits>
+    struct get_string_comparison_category {
+        using type = weak_ordering;
+    };
+
+    template <class Traits>
+        requires requires { typename Traits::comparison_category; }
+    struct get_string_comparison_category<Traits> {
+        using type = Traits::comparison_category;
+
+        static_assert(disjunction_v<is_same<type, partial_ordering>, is_same<type, weak_ordering>,
+            is_same<type, strong_ordering>>);
+    };
+
+    template <class Traits>
+    using get_string_comparison_category_t = get_string_comparison_category<Traits>::type;
+
+    template <class Traits>
+    concept characterized_traits = requires { typename Traits::is_characterized; };
+
+#ifdef __clang__ // TRANSITION, LLVM-75404
+#define CONST_PARAM const
+#else // ^^^ workaround / no workaround vvv
+#define CONST_PARAM
+#endif // ^^^ no workaround ^^^
+
+    template <class CharT, characterized_traits Traits>
+    constexpr bool operator==(CONST_PARAM basic_string_view<CharT, Traits> x,
+        CONST_PARAM type_identity_t<basic_string_view<CharT, Traits>> y) noexcept {
+        return x.size() == y.size() && x.compare(y) == 0;
+    }
+    template <class CharT, characterized_traits Traits>
+    constexpr get_string_comparison_category_t<Traits> operator<=>(CONST_PARAM basic_string_view<CharT, Traits> x,
+        CONST_PARAM type_identity_t<basic_string_view<CharT, Traits>> y) noexcept {
+        return static_cast<get_string_comparison_category_t<Traits>>(x.compare(y) <=> 0);
+    }
+
+    template <class CharT>
+    struct test_traits : char_traits<CharT> {
+        using is_characterized = void;
+    };
+
+    using test_string_view = basic_string_view<char, test_traits<char>>;
+
+    static_assert(test_string_view{} == test_string_view{});
+    static_assert(!(test_string_view{} != test_string_view{}));
+    static_assert(!(test_string_view{} < test_string_view{}));
+    static_assert(!(test_string_view{} > test_string_view{}));
+    static_assert(test_string_view{} <= test_string_view{});
+    static_assert(test_string_view{} >= test_string_view{});
+    static_assert(test_string_view{} <=> test_string_view{} == strong_ordering::equal);
+
+    static_assert(test_string_view{} == "");
+    static_assert(!(test_string_view{} != ""));
+    static_assert(!(test_string_view{} < ""));
+    static_assert(!(test_string_view{} > ""));
+    static_assert(test_string_view{} <= "");
+    static_assert(test_string_view{} >= "");
+    static_assert(test_string_view{} <=> "" == strong_ordering::equal);
+
+    static_assert("" == test_string_view{});
+    static_assert(!("" != test_string_view{}));
+    static_assert(!("" < test_string_view{}));
+    static_assert(!("" > test_string_view{}));
+    static_assert("" <= test_string_view{});
+    static_assert("" >= test_string_view{});
+    static_assert("" <=> test_string_view{} == strong_ordering::equal);
+} // namespace test_lwg_3950
+#endif // _HAS_CXX20
+
 int main() {
     test_case_default_constructor();
     test_case_ntcts_constructor();

From 53f95ba92eff8ba24c5a3589916c2a9a50441ca2 Mon Sep 17 00:00:00 2001
From: grcm10 <141476191+grcm10@users.noreply.github.com>
Date: Fri, 29 Mar 2024 02:24:34 +0900
Subject: [PATCH 14/45] Implement LWG-4035 single_view should provide empty
 (#4525)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/ranges                                | 4 ++++
 tests/std/tests/P0896R4_views_single/test.cpp | 7 +++++++
 2 files changed, 11 insertions(+)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 30d22d9c4f5..d2949c677ae 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -1031,6 +1031,10 @@ namespace ranges {
             return data() + 1;
         }
 
+        _NODISCARD static constexpr bool empty() noexcept {
+            return false;
+        }
+
         _NODISCARD static constexpr size_t size() noexcept {
             return 1;
         }
diff --git a/tests/std/tests/P0896R4_views_single/test.cpp b/tests/std/tests/P0896R4_views_single/test.cpp
index 8671a901053..ccf315b8d25 100644
--- a/tests/std/tests/P0896R4_views_single/test.cpp
+++ b/tests/std/tests/P0896R4_views_single/test.cpp
@@ -52,6 +52,13 @@ constexpr bool test_one_type(T value, Args&&... args) {
     same_as<R> auto r0 = ranges::single_view{value};
     const R& cr0       = r0;
 
+    // validate member empty
+    static_assert(same_as<decltype(R::empty()), bool>);
+    static_assert(R::empty() == false);
+    static_assert(noexcept(R::empty()));
+    static_assert(noexcept(ranges::empty(r0)));
+    static_assert(noexcept(ranges::empty(cr0)));
+
     // validate member size
     static_assert(same_as<decltype(R::size()), size_t>);
     static_assert(R::size() == 1);

From 983b26dacf624de51f00b32420588504425440a1 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 29 Mar 2024 01:27:28 +0800
Subject: [PATCH 15/45] Implement LWG-3919 `enumerate_view` may invoke UB for
 sized common non-forward underlying ranges (#4526)

---
 stl/inc/ranges                                   | 4 ++--
 tests/std/tests/P2164R9_views_enumerate/test.cpp | 5 +++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index d2949c677ae..5569d43725c 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -6390,7 +6390,7 @@ namespace ranges {
         _NODISCARD constexpr auto end() noexcept(_Is_end_nothrow_v<_Vw>) // strengthened
             requires (!_Simple_view<_Vw>)
         {
-            if constexpr (common_range<_Vw> && sized_range<_Vw>) {
+            if constexpr (forward_range<_Vw> && common_range<_Vw> && sized_range<_Vw>) {
                 return _Iterator<false>{_RANGES end(_Range), _RANGES distance(_Range)};
             } else {
                 return _Sentinel<false>{_RANGES end(_Range)};
@@ -6400,7 +6400,7 @@ namespace ranges {
         _NODISCARD constexpr auto end() const noexcept(_Is_end_nothrow_v<const _Vw>) // strengthened
             requires _Range_with_movable_references<const _Vw>
         {
-            if constexpr (common_range<const _Vw> && sized_range<const _Vw>) {
+            if constexpr (forward_range<const _Vw> && common_range<const _Vw> && sized_range<const _Vw>) {
                 return _Iterator<true>{_RANGES end(_Range), _RANGES distance(_Range)};
             } else {
                 return _Sentinel<true>{_RANGES end(_Range)};
diff --git a/tests/std/tests/P2164R9_views_enumerate/test.cpp b/tests/std/tests/P2164R9_views_enumerate/test.cpp
index b0b26ed5db7..36d2d010d6f 100644
--- a/tests/std/tests/P2164R9_views_enumerate/test.cpp
+++ b/tests/std/tests/P2164R9_views_enumerate/test.cpp
@@ -203,7 +203,7 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
             assert((as_const(r).begin() == s) == is_empty);
         }
 
-        STATIC_ASSERT(common_range<R> == (common_range<V> && sized_range<V>) );
+        STATIC_ASSERT(common_range<R> == (forward_range<V> && common_range<V> && sized_range<V>) );
         if constexpr (common_range<V> && sized_range<V> && bidirectional_range<V>) {
             if (!is_empty) {
                 assert(*prev(s) == *prev(end(expected)));
@@ -228,7 +228,8 @@ constexpr bool test_one(Rng&& rng, Expected&& expected) {
             assert((r.begin() == cs) == is_empty);
         }
 
-        STATIC_ASSERT(common_range<const R> == (common_range<const V> && sized_range<const V>) );
+        STATIC_ASSERT(
+            common_range<const R> == (forward_range<const V> && common_range<const V> && sized_range<const V>) );
         if constexpr (common_range<const V> && sized_range<const V> && bidirectional_range<const V>) {
             if (!is_empty) {
                 assert(*prev(cs) == *prev(end(expected)));

From 80387d3fd3a4b262dc54b47cc9089b0fe6f38e96 Mon Sep 17 00:00:00 2001
From: Igor Zhukov <fsb4000@yandex.ru>
Date: Fri, 29 Mar 2024 00:33:45 +0700
Subject: [PATCH 16/45] Add an STL-wide suppression for C5246 (#4527)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/yvals_core.h                              |  3 ++-
 tests/std/test.lst                                |  1 +
 .../tests/GH_004477_mdspan_warning_5246/env.lst   |  6 ++++++
 .../test.compile.pass.cpp                         | 15 +++++++++++++++
 4 files changed, 24 insertions(+), 1 deletion(-)
 create mode 100644 tests/std/tests/GH_004477_mdspan_warning_5246/env.lst
 create mode 100644 tests/std/tests/GH_004477_mdspan_warning_5246/test.compile.pass.cpp

diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index daceb8f32d5..ef3883a4274 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -805,6 +805,7 @@
 // warning C5045: Compiler will insert Spectre mitigation for memory load if /Qspectre switch specified (/Wall)
 // warning C5220: a non-static data member with a volatile qualified type no longer implies that compiler generated
 //                copy/move constructors and copy/move assignment operators are not trivial (/Wall)
+// warning C5246: 'member': the initialization of a subobject should be wrapped in braces (/Wall)
 // warning C6294: Ill-defined for-loop: initial condition does not satisfy test. Loop body not executed
 
 #ifndef _STL_DISABLED_WARNINGS
@@ -812,7 +813,7 @@
 #define _STL_DISABLED_WARNINGS                        \
     4180 4324 4412 4455 4494 4514 4574 4582 4583 4587 \
     4588 4619 4623 4625 4626 4643 4648 4702 4793 4820 \
-    4868 4988 5026 5027 5045 5220 6294                \
+    4868 4988 5026 5027 5045 5220 5246 6294           \
     _STL_DISABLED_WARNING_C4577                       \
     _STL_DISABLED_WARNING_C4984                       \
     _STL_DISABLED_WARNING_C5053                       \
diff --git a/tests/std/test.lst b/tests/std/test.lst
index f854b835230..d52d2b4b281 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -241,6 +241,7 @@ tests\GH_004129_conversion_in_new_numeric_algorithms
 tests\GH_004201_chrono_formatter
 tests\GH_004275_seeking_fancy_iterators
 tests\GH_004388_unordered_meow_operator_equal
+tests\GH_004477_mdspan_warning_5246
 tests\LWG2381_num_get_floating_point
 tests\LWG2597_complex_branch_cut
 tests\LWG3018_shared_ptr_function
diff --git a/tests/std/tests/GH_004477_mdspan_warning_5246/env.lst b/tests/std/tests/GH_004477_mdspan_warning_5246/env.lst
new file mode 100644
index 00000000000..f19e2c8fd7a
--- /dev/null
+++ b/tests/std/tests/GH_004477_mdspan_warning_5246/env.lst
@@ -0,0 +1,6 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_latest_matrix.lst
+RUNALL_CROSSLIST
+*	PM_CL="/w15246"
diff --git a/tests/std/tests/GH_004477_mdspan_warning_5246/test.compile.pass.cpp b/tests/std/tests/GH_004477_mdspan_warning_5246/test.compile.pass.cpp
new file mode 100644
index 00000000000..1844f28418f
--- /dev/null
+++ b/tests/std/tests/GH_004477_mdspan_warning_5246/test.compile.pass.cpp
@@ -0,0 +1,15 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <array>
+#include <cstddef>
+#include <mdspan>
+
+using namespace std;
+
+// Test GH-4477 "Using std::mdspan results in multiple warnings (C5246)"
+void test_gh_4477() {
+    array test_data{0, 1, 2, 3, 4, 5};
+    mdspan<int, dextents<size_t, 2>> test_span(test_data.data(), 2, 3);
+    (void) test_span;
+}

From ece6dd34830caa8c5f884fdccb489b08fc34d5e6 Mon Sep 17 00:00:00 2001
From: yronglin <yronglin777@gmail.com>
Date: Fri, 29 Mar 2024 01:48:17 +0800
Subject: [PATCH 17/45] `<tuple>`: Make `std::make_from_tuple` SFINAE friendly
 (#4528)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/tuple                                 | 21 +++---
 tests/std/test.lst                            |  1 +
 .../LWG3528_make_from_tuple_impl/env.lst      |  4 +
 .../test.compile.pass.cpp                     | 74 +++++++++++++++++++
 4 files changed, 91 insertions(+), 9 deletions(-)
 create mode 100644 tests/std/tests/LWG3528_make_from_tuple_impl/env.lst
 create mode 100644 tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp

diff --git a/stl/inc/tuple b/stl/inc/tuple
index c49a9205c5f..66edcc20877 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -1079,24 +1079,27 @@ constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
         make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{});
 }
 
-#if _HAS_CXX23
-template <class _Ty, _Tuple_like _Tuple, size_t... _Indices>
-#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+template <class _Ty, class _Tuple, class _Seq = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>>
+inline constexpr bool _Can_make_from_tuple = false;
+template <class _Ty, class _Tuple, size_t... _Indices>
+inline constexpr bool _Can_make_from_tuple<_Ty, _Tuple, index_sequence<_Indices...>> =
+    is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD declval<_Tuple>()))...>;
+
 template <class _Ty, class _Tuple, size_t... _Indices>
-#endif // ^^^ !_HAS_CXX23 ^^^
 constexpr _Ty _Make_from_tuple_impl(_Tuple&& _Tpl, index_sequence<_Indices...>) noexcept(
     is_nothrow_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>) {
-    // construct _Ty from the elements of _Tpl
-    static_assert(is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl)))...>,
-        "the target type must be constructible from the fields of the argument tuple (N4950 [tuple.apply]/4).");
     return _Ty(_STD get<_Indices>(_STD forward<_Tuple>(_Tpl))...);
 }
 
 #if _HAS_CXX23
 _EXPORT_STD template <class _Ty, _Tuple_like _Tuple>
-#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#elif _HAS_CXX20
 _EXPORT_STD template <class _Ty, class _Tuple>
-#endif // ^^^ !_HAS_CXX23 ^^^
+    requires _Can_make_from_tuple<_Ty, _Tuple>
+#else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
+template <class _Ty, class _Tuple, enable_if_t<_Can_make_from_tuple<_Ty, _Tuple>, int> = 0>
+#endif // ^^^ !_HAS_CXX20 ^^^
 _NODISCARD constexpr _Ty make_from_tuple(_Tuple&& _Tpl) noexcept(noexcept(_STD _Make_from_tuple_impl<_Ty>(
     _STD forward<_Tuple>(_Tpl), make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>{}))) /* strengthened */ {
     // construct _Ty from the elements of _Tpl
diff --git a/tests/std/test.lst b/tests/std/test.lst
index d52d2b4b281..cf8d9bf3ef1 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -250,6 +250,7 @@ tests\LWG3146_excessive_unwrapping_ref_cref
 tests\LWG3234_math_special_overloads
 tests\LWG3422_seed_seq_ctors
 tests\LWG3480_directory_iterator_range
+tests\LWG3528_make_from_tuple_impl
 tests\LWG3545_pointer_traits_sfinae
 tests\LWG3561_discard_block_engine_counter
 tests\LWG3610_iota_view_size_and_integer_class
diff --git a/tests/std/tests/LWG3528_make_from_tuple_impl/env.lst b/tests/std/tests/LWG3528_make_from_tuple_impl/env.lst
new file mode 100644
index 00000000000..2de7aab2959
--- /dev/null
+++ b/tests/std/tests/LWG3528_make_from_tuple_impl/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_17_matrix.lst
diff --git a/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp b/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp
new file mode 100644
index 00000000000..0ca11479715
--- /dev/null
+++ b/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp
@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//===----------------------------------------------------------------------===//
+
+// derived from libc++'s test files:
+// * std/utilities/tuple/tuple.tuple/tuple.apply/make_from_tuple.pass.cpp
+
+#include <array>
+#include <tuple>
+#include <type_traits>
+#include <utility>
+
+struct A {
+    int a;
+};
+
+enum class D {
+    one,
+    two,
+};
+
+template <class T, class Tuple, class = void>
+inline constexpr bool has_make_from_tuple = false;
+
+template <class T, class Tuple>
+inline constexpr bool
+    has_make_from_tuple<T, Tuple, std::void_t<decltype(std::make_from_tuple<T>(std::declval<Tuple>()))>> = true;
+
+// Test std::make_from_tuple.
+
+// reinterpret_cast, std::tuple<T>
+static_assert(!has_make_from_tuple<int*, std::tuple<A*>>);
+static_assert(has_make_from_tuple<A*, std::tuple<A*>>);
+
+// reinterpret_cast, std::array<T, 1>
+static_assert(!has_make_from_tuple<int*, std::array<A*, 1>>);
+static_assert(has_make_from_tuple<A*, std::array<A*, 1>>);
+
+// const_cast, std::tuple<T>
+static_assert(!has_make_from_tuple<char*, std::tuple<const char*>>);
+static_assert(!has_make_from_tuple<volatile char*, std::tuple<const volatile char*>>);
+static_assert(has_make_from_tuple<volatile char*, std::tuple<volatile char*>>);
+static_assert(has_make_from_tuple<char*, std::tuple<char*>>);
+static_assert(has_make_from_tuple<const char*, std::tuple<char*>>);
+static_assert(has_make_from_tuple<const volatile char*, std::tuple<volatile char*>>);
+
+// const_cast, std::array<T, 1>
+static_assert(!has_make_from_tuple<char*, std::array<const char*, 1>>);
+static_assert(!has_make_from_tuple<volatile char*, std::array<const volatile char*, 1>>);
+static_assert(has_make_from_tuple<volatile char*, std::array<volatile char*, 1>>);
+static_assert(has_make_from_tuple<char*, std::array<char*, 1>>);
+static_assert(has_make_from_tuple<const char*, std::array<char*, 1>>);
+static_assert(has_make_from_tuple<const volatile char*, std::array<volatile char*, 1>>);
+
+// static_cast, std::tuple<T>
+static_assert(!has_make_from_tuple<int, std::tuple<D>>);
+static_assert(!has_make_from_tuple<D, std::tuple<int>>);
+static_assert(has_make_from_tuple<long, std::tuple<int>>);
+static_assert(has_make_from_tuple<double, std::tuple<float>>);
+static_assert(has_make_from_tuple<float, std::tuple<double>>);
+
+// static_cast, std::array<T, 1>
+static_assert(!has_make_from_tuple<int, std::array<D, 1>>);
+static_assert(!has_make_from_tuple<D, std::array<int, 1>>);
+static_assert(has_make_from_tuple<long, std::array<int, 1>>);
+static_assert(has_make_from_tuple<double, std::array<float, 1>>);
+static_assert(has_make_from_tuple<float, std::array<double, 1>>);

From 370f9a9a6f631f6b6e788fd05dba065493e996ae Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 29 Mar 2024 01:56:34 +0800
Subject: [PATCH 18/45] Implement LWG-4012 `common_view::begin`/`end` are
 missing the `simple-view` check (#4529)

---
 stl/inc/ranges                                |  8 +++--
 tests/std/tests/P0896R4_views_common/test.cpp | 31 +++++++++++++++++++
 2 files changed, 37 insertions(+), 2 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 5569d43725c..0cc85f60e1c 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -5289,7 +5289,9 @@ namespace ranges {
         }
 
         _NODISCARD constexpr auto begin() noexcept(
-            noexcept(_RANGES begin(_Base)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */ {
+            noexcept(_RANGES begin(_Base)) && is_nothrow_move_constructible_v<iterator_t<_Vw>>) /* strengthened */
+            requires (!_Simple_view<_Vw>)
+        {
             if constexpr (random_access_range<_Vw> && sized_range<_Vw>) {
                 return _RANGES begin(_Base);
             } else {
@@ -5308,7 +5310,9 @@ namespace ranges {
             }
         }
 
-        _NODISCARD constexpr auto end() {
+        _NODISCARD constexpr auto end()
+            requires (!_Simple_view<_Vw>)
+        {
             if constexpr (random_access_range<_Vw> && sized_range<_Vw>) {
                 return _RANGES begin(_Base) + _RANGES distance(_Base);
             } else {
diff --git a/tests/std/tests/P0896R4_views_common/test.cpp b/tests/std/tests/P0896R4_views_common/test.cpp
index 04daf0fd82e..ed32cfa116a 100644
--- a/tests/std/tests/P0896R4_views_common/test.cpp
+++ b/tests/std/tests/P0896R4_views_common/test.cpp
@@ -541,6 +541,34 @@ constexpr bool test_lwg3717() {
     return true;
 }
 
+constexpr bool test_lwg_4012() {
+    struct simple_view_with_difference_on_const : ranges::view_interface<simple_view_with_difference_on_const> {
+        constexpr difference_type_only_iterator<int> begin() noexcept {
+            return {nullptr};
+        }
+        constexpr difference_type_only_sentinel<int> end() noexcept {
+            return {nullptr};
+        }
+        constexpr difference_type_only_iterator<int> begin() const noexcept {
+            return {p_};
+        }
+        constexpr difference_type_only_sentinel<int> end() const noexcept {
+            return {p_};
+        }
+
+        int* p_;
+    };
+
+    int n{};
+    auto cv = views::common(simple_view_with_difference_on_const{{}, &n});
+
+    assert(cv.begin() == as_const(cv).begin());
+    assert(cv.begin() == as_const(cv).end());
+    assert(as_const(cv).begin() == cv.end());
+
+    return true;
+}
+
 int main() {
     // Get full instantiation coverage
     static_assert((test_in<instantiator, const int>(), true));
@@ -551,4 +579,7 @@ int main() {
 
     assert(test_lwg3717<int>());
     assert(test_lwg3717<const int>());
+
+    static_assert(test_lwg_4012());
+    test_lwg_4012();
 }

From d8f6dc5e8bd3e812480a956fb5c3954cf1d7d768 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 29 Mar 2024 02:00:25 +0800
Subject: [PATCH 19/45] Implement LWG-4013
 `lazy_split_view::outer-iterator::value_type` should not provide default
 constructor (#4530)

---
 stl/inc/ranges                                   |  7 ++++---
 tests/libcxx/expected_results.txt                |  4 ++++
 .../std/tests/P0896R4_views_lazy_split/test.cpp  | 16 ++++++++++++++++
 3 files changed, 24 insertions(+), 3 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 0cc85f60e1c..37e9db92824 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -4706,12 +4706,13 @@ namespace ranges {
             private:
                 /* [[no_unique_address]] */ _Outer_iter _First{};
 
-            public:
-                value_type() = default;
                 constexpr explicit value_type(_Outer_iter _First_) noexcept(
-                    is_nothrow_move_constructible_v<_Outer_iter>) // strengthened
+                    is_nothrow_move_constructible_v<_Outer_iter>)
                     : _First{_STD move(_First_)} {}
 
+                friend _Outer_iter;
+
+            public:
                 _NODISCARD constexpr auto begin() const {
                     return _Inner_iter<_Const>{_First};
                 }
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index 69cabaff366..ba26ae5bc1f 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -165,6 +165,10 @@ std/utilities/memory/specialized.algorithms/uninitialized.fill.n/ranges_uninitia
 std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move.pass.cpp FAIL
 std/utilities/memory/specialized.algorithms/uninitialized.move/ranges_uninitialized_move_n.pass.cpp FAIL
 
+# libc++ doesn't implement LWG-4013
+std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.default.pass.cpp FAIL
+std/ranges/range.adaptors/range.lazy.split/range.lazy.split.outer.value/ctor.iter.pass.cpp FAIL
+
 # If any feature-test macro test is failing, this consolidated test will also fail.
 std/language.support/support.limits/support.limits.general/version.version.compile.pass.cpp FAIL
 
diff --git a/tests/std/tests/P0896R4_views_lazy_split/test.cpp b/tests/std/tests/P0896R4_views_lazy_split/test.cpp
index 8a688e0da39..1400ffe8a1b 100644
--- a/tests/std/tests/P0896R4_views_lazy_split/test.cpp
+++ b/tests/std/tests/P0896R4_views_lazy_split/test.cpp
@@ -63,6 +63,10 @@ constexpr void test_one(Base&& base, Delimiter&& delimiter, Expected&& expected)
 
         STATIC_ASSERT(same_as<decltype(base | closure), R>);
         STATIC_ASSERT(noexcept(base | closure) == is_noexcept);
+
+        using outer_iterator = decltype(views::lazy_split(base, delimiter).begin());
+        STATIC_ASSERT(!is_default_constructible_v<iter_value_t<outer_iterator>>); // LWG-4013
+        STATIC_ASSERT(!is_constructible_v<iter_value_t<outer_iterator>, outer_iterator>); // LWG-4013
     }
 
     // ... with const lvalue argument
@@ -77,6 +81,10 @@ constexpr void test_one(Base&& base, Delimiter&& delimiter, Expected&& expected)
 
         STATIC_ASSERT(same_as<decltype(as_const(base) | closure), R>);
         STATIC_ASSERT(noexcept(as_const(base) | closure) == is_noexcept);
+
+        using outer_iterator = decltype(views::lazy_split(as_const(base), delimiter).begin());
+        STATIC_ASSERT(!is_default_constructible_v<iter_value_t<outer_iterator>>); // LWG-4013
+        STATIC_ASSERT(!is_constructible_v<iter_value_t<outer_iterator>, outer_iterator>); // LWG-4013
     } else if constexpr (!is_view) {
         using LSV                  = ranges::lazy_split_view<ranges::ref_view<const remove_reference_t<Base>>, DV>;
         constexpr bool is_noexcept = is_nothrow_constructible_v<LSV, const remove_reference_t<Base>&, Delimiter&>;
@@ -99,6 +107,10 @@ constexpr void test_one(Base&& base, Delimiter&& delimiter, Expected&& expected)
 
         STATIC_ASSERT(same_as<decltype(move(base) | closure), R>);
         STATIC_ASSERT(noexcept(move(base) | closure) == is_noexcept);
+
+        using outer_iterator = decltype(views::lazy_split(move(base), delimiter).begin());
+        STATIC_ASSERT(!is_default_constructible_v<iter_value_t<outer_iterator>>); // LWG-4013
+        STATIC_ASSERT(!is_constructible_v<iter_value_t<outer_iterator>, outer_iterator>); // LWG-4013
     } else if constexpr (movable<remove_reference_t<Base>>) {
         using RS = ranges::lazy_split_view<ranges::owning_view<remove_reference_t<Base>>, DV>;
         constexpr bool is_noexcept =
@@ -123,6 +135,10 @@ constexpr void test_one(Base&& base, Delimiter&& delimiter, Expected&& expected)
 
         STATIC_ASSERT(same_as<decltype(move(as_const(base)) | closure), R>);
         STATIC_ASSERT(noexcept(move(as_const(base)) | closure) == is_noexcept);
+
+        using outer_iterator = decltype(views::lazy_split(move(as_const(base)), delimiter).begin());
+        STATIC_ASSERT(!is_default_constructible_v<iter_value_t<outer_iterator>>); // LWG-4013
+        STATIC_ASSERT(!is_constructible_v<iter_value_t<outer_iterator>, outer_iterator>); // LWG-4013
     }
 
     // Validate deduction guide

From fbdcee4978d733ab5bd231fea207c887f80e4e17 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Fri, 29 Mar 2024 02:04:05 +0800
Subject: [PATCH 20/45] Implement P2875R4 Undeprecate
 `polymorphic_allocator::destroy` (#4532)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/xpolymorphic_allocator.h                    |  6 +++---
 stl/inc/yvals_core.h                                | 13 ++-----------
 .../P0220R1_polymorphic_memory_resources/test.cpp   |  1 -
 3 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/stl/inc/xpolymorphic_allocator.h b/stl/inc/xpolymorphic_allocator.h
index d6b34b3d146..0903ce5863f 100644
--- a/stl/inc/xpolymorphic_allocator.h
+++ b/stl/inc/xpolymorphic_allocator.h
@@ -269,7 +269,7 @@ namespace pmr {
 
         template <class _Uty>
         void delete_object(_Uty* const _Ptr) noexcept /* strengthened */ {
-            _STD _Destroy_in_place(*_Ptr);
+            _Ptr->~_Uty();
             deallocate_object(_Ptr);
         }
 #endif // _HAS_CXX20
@@ -296,8 +296,8 @@ namespace pmr {
         }
 
         template <class _Uty>
-        _CXX17_DEPRECATE_POLYMORPHIC_ALLOCATOR_DESTROY void destroy(_Uty* const _Ptr) noexcept /* strengthened */ {
-            _STD _Destroy_in_place(*_Ptr);
+        void destroy(_Uty* const _Ptr) noexcept /* strengthened */ {
+            _Ptr->~_Uty();
         }
 
         _NODISCARD polymorphic_allocator select_on_container_copy_construction() const noexcept /* strengthened */ {
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index ef3883a4274..e027e322a9c 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -132,6 +132,7 @@
 // P2338R4 Freestanding Library: Character Primitives And The C Library
 //     (including __cpp_lib_freestanding_charconv)
 // P2517R1 Conditional noexcept For apply()
+// P2875R4 Undeprecate polymorphic_allocator::destroy
 
 // _HAS_CXX17 indirectly controls:
 // N4190 Removing auto_ptr, random_shuffle(), And Old <functional> Stuff
@@ -1387,17 +1388,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define _CXX20_DEPRECATE_MOVE_ITERATOR_ARROW
 #endif // ^^^ warning disabled ^^^
 
-#if _HAS_CXX17 && !defined(_SILENCE_CXX17_POLYMORPHIC_ALLOCATOR_DESTROY_DEPRECATION_WARNING) \
-    && !defined(_SILENCE_ALL_CXX17_DEPRECATION_WARNINGS)
-#define _CXX17_DEPRECATE_POLYMORPHIC_ALLOCATOR_DESTROY                                                   \
-    [[deprecated("warning STL4032: "                                                                     \
-                 "std::pmr::polymorphic_allocator::destroy() is deprecated in C++17 by LWG-3036. "       \
-                 "Prefer std::destroy_at() or std::allocator_traits<polymorphic_allocator>::destroy(). " \
-                 "You can define _SILENCE_CXX17_POLYMORPHIC_ALLOCATOR_DESTROY_DEPRECATION_WARNING "      \
-                 "or _SILENCE_ALL_CXX17_DEPRECATION_WARNINGS to suppress this warning.")]]
-#else // ^^^ warning enabled / warning disabled vvv
-#define _CXX17_DEPRECATE_POLYMORPHIC_ALLOCATOR_DESTROY
-#endif // ^^^ warning disabled ^^^
+// STL4032 was "std::pmr::polymorphic_allocator::destroy() is deprecated in C++17 by LWG-3036." (reverted by P2875R4)
 
 #if _HAS_CXX20 && !defined(_SILENCE_CXX20_IS_ALWAYS_EQUAL_DEPRECATION_WARNING) \
     && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
diff --git a/tests/std/tests/P0220R1_polymorphic_memory_resources/test.cpp b/tests/std/tests/P0220R1_polymorphic_memory_resources/test.cpp
index 933c0029a63..99f7c1d6ea3 100644
--- a/tests/std/tests/P0220R1_polymorphic_memory_resources/test.cpp
+++ b/tests/std/tests/P0220R1_polymorphic_memory_resources/test.cpp
@@ -1,7 +1,6 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
-#define _SILENCE_CXX17_POLYMORPHIC_ALLOCATOR_DESTROY_DEPRECATION_WARNING
 #define _SILENCE_CXX23_ALIGNED_UNION_DEPRECATION_WARNING
 
 #include <algorithm>

From 4a14a494086ce5a178471ebb119ae0649c5b46aa Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 28 Mar 2024 15:36:44 -0700
Subject: [PATCH 21/45] `vector_algorithms.cpp`: Fix ARM64EC build break
 (#4538)

---
 stl/src/vector_algorithms.cpp | 13 +++++++------
 1 file changed, 7 insertions(+), 6 deletions(-)

diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index a5a637695e6..1c5fc74e809 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -10,6 +10,7 @@
 #include <cstdint>
 #include <cstring>
 #include <xtr1common>
+
 #ifndef _M_ARM64EC
 #include <intrin.h>
 #include <isa_availability.h>
@@ -47,6 +48,12 @@ namespace {
             _mm256_zeroupper();
         }
     };
+
+    __m256i _Avx2_tail_mask_32(const size_t _Count_in_dwords) noexcept {
+        // _Count_in_dwords must be within [1, 7].
+        static constexpr unsigned int _Tail_masks[14] = {~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0, 0, 0, 0};
+        return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Tail_masks + (7 - _Count_in_dwords)));
+    }
 } // namespace
 #endif // !defined(_M_ARM64EC)
 
@@ -88,12 +95,6 @@ namespace {
     void _Advance_bytes(const void*& _Target, _Integral _Offset) noexcept {
         _Target = static_cast<const unsigned char*>(_Target) + _Offset;
     }
-
-    __m256i _Avx2_tail_mask_32(const size_t _Count_in_dwords) noexcept {
-        // _Count_in_dwords must be within [1, 7].
-        static constexpr unsigned int _Tail_masks[14] = {~0u, ~0u, ~0u, ~0u, ~0u, ~0u, ~0u, 0, 0, 0, 0, 0, 0, 0};
-        return _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_Tail_masks + (7 - _Count_in_dwords)));
-    }
 } // unnamed namespace
 
 extern "C" {

From be81252ed1f5e5fc6d77faca0b5dbbbdae8143a2 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Thu, 28 Mar 2024 17:01:15 -0700
Subject: [PATCH 22/45] `create-1es-hosted-pool.ps1`: Avoid
 `ConvertTo-SecureString` (#4535)

---
 azure-devops/create-1es-hosted-pool.ps1 | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/azure-devops/create-1es-hosted-pool.ps1 b/azure-devops/create-1es-hosted-pool.ps1
index 232464f305f..bba0c57a831 100644
--- a/azure-devops/create-1es-hosted-pool.ps1
+++ b/azure-devops/create-1es-hosted-pool.ps1
@@ -79,9 +79,9 @@ function New-Password {
     }
   }
 
-  $result = ''
+  [SecureString] $result = [SecureString]::new()
   for ($idx = 0; $idx -lt $Length; $idx++) {
-    $result += $alphabet[$randomData[$idx] -band $mask]
+    $result.AppendChar($alphabet[$randomData[$idx] -band $mask])
   }
 
   return $result
@@ -143,8 +143,7 @@ New-AzResourceGroup `
 ####################################################################################################
 Display-ProgressBar -Status 'Creating credentials'
 
-$AdminPW = New-Password
-$AdminPWSecure = ConvertTo-SecureString $AdminPW -AsPlainText -Force
+$AdminPWSecure = New-Password
 $Credential = New-Object System.Management.Automation.PSCredential ('AdminUser', $AdminPWSecure)
 
 ####################################################################################################

From d65508307e9f93a4ed78e96b42b0876966c6acef Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 03:33:47 +0800
Subject: [PATCH 23/45] `<cmath>`: Complete additional overloads for integers
 (#4537)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/cmath                                 |  91 ++++++++-
 tests/libcxx/expected_results.txt             |   4 -
 tests/std/test.lst                            |   1 +
 .../GH_000519_cmath_int_overloads/env.lst     |   4 +
 .../GH_000519_cmath_int_overloads/test.cpp    | 190 ++++++++++++++++++
 5 files changed, 285 insertions(+), 5 deletions(-)
 create mode 100644 tests/std/tests/GH_000519_cmath_int_overloads/env.lst
 create mode 100644 tests/std/tests/GH_000519_cmath_int_overloads/test.cpp

diff --git a/stl/inc/cmath b/stl/inc/cmath
index 8bb994af15b..f4e0ae7072d 100644
--- a/stl/inc/cmath
+++ b/stl/inc/cmath
@@ -594,6 +594,50 @@ _STD _Common_float_type_t<_Ty1, _Ty2> remquo(_Ty1 _Left, _Ty2 _Right, int* _Pquo
     }
 }
 
+// TRANSITION, GH-519, should be provided by UCRT
+template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>
+_NODISCARD _Check_return_ _CONSTEXPR23 int fpclassify(_In_ const _Ty _Ix) noexcept /* strengthened */ {
+    return _Ix == 0 ? FP_ZERO : FP_NORMAL;
+}
+
+// TRANSITION, GH-519, should be provided by UCRT
+template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0>
+_NODISCARD _Check_return_ _CONSTEXPR23 bool signbit(_In_ const _Ty _Ix) noexcept /* strengthened */ {
+    if constexpr (static_cast<_Ty>(-1) < _Ty{}) {
+        return _Ix < 0;
+    } else {
+        return false;
+    }
+}
+
+// TRANSITION, GH-519, additional overloads are not templated to avoid ambiguity with the major overload in UCRT
+#define _GENERIC_MATH_ISNORMAL(TYPE)                                                                        \
+    _NODISCARD _Check_return_ _CONSTEXPR23 bool isnormal(_In_ const TYPE _Ix) noexcept /* strengthened */ { \
+        return _Ix != 0;                                                                                    \
+    }
+
+_GENERIC_MATH_ISNORMAL(signed char)
+_GENERIC_MATH_ISNORMAL(unsigned char)
+_GENERIC_MATH_ISNORMAL(short)
+_GENERIC_MATH_ISNORMAL(unsigned short)
+_GENERIC_MATH_ISNORMAL(int)
+_GENERIC_MATH_ISNORMAL(unsigned int)
+_GENERIC_MATH_ISNORMAL(long)
+_GENERIC_MATH_ISNORMAL(unsigned long)
+_GENERIC_MATH_ISNORMAL(long long)
+_GENERIC_MATH_ISNORMAL(unsigned long long)
+_GENERIC_MATH_ISNORMAL(bool)
+_GENERIC_MATH_ISNORMAL(char)
+#ifdef __cpp_char8_t
+_GENERIC_MATH_ISNORMAL(char8_t)
+#endif // defined(__cpp_char8_t)
+_GENERIC_MATH_ISNORMAL(char16_t)
+_GENERIC_MATH_ISNORMAL(char32_t)
+#ifdef _NATIVE_WCHAR_T_DEFINED
+_GENERIC_MATH_ISNORMAL(wchar_t)
+#endif // defined(_NATIVE_WCHAR_T_DEFINED)
+#undef _GENERIC_MATH_ISNORMAL
+
 #define _GENERIC_MATH1_BASE(NAME, RET, FUN)                                  \
     template <class _Ty, _STD enable_if_t<_STD is_integral_v<_Ty>, int> = 0> \
     _NODISCARD RET NAME(_Ty _Left) noexcept /* strengthened */ {             \
@@ -640,6 +684,42 @@ _STD _Common_float_type_t<_Ty1, _Ty2> remquo(_Ty1 _Left, _Ty2 _Right, int* _Pquo
 #define _GENERIC_MATH2I(FUN, CLANG_INTRIN, MSVC_INTRIN) _GENERIC_MATH2_BASE(FUN, _CSTD FUN)
 #endif // ^^^ intrinsics unavailable ^^^
 
+// TRANSITION, GH-519, additional overloads are not templated to avoid ambiguity with the major overload in UCRT
+#define _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, TYPE)                                \
+    _NODISCARD _Check_return_ _CONSTEXPR23 bool FUN(_In_ TYPE) noexcept /* strengthened */ { \
+        return RETV;                                                                         \
+    }
+
+#ifdef __cpp_char8_t
+#define _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T(FUN, RETV) _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char8_t)
+#else // ^^^ defined(__cpp_char8_t) / !defined(__cpp_char8_t) vvv
+#define _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T(FUN, RETV)
+#endif // ^^^ !defined(__cpp_char8_t) ^^^
+
+#ifdef _NATIVE_WCHAR_T_DEFINED
+#define _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T(FUN, RETV) _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, wchar_t)
+#else // ^^^ defined(_NATIVE_WCHAR_T_DEFINED) / !defined(_NATIVE_WCHAR_T_DEFINED) vvv
+#define _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T(FUN, RETV)
+#endif // ^^^ !defined(_NATIVE_WCHAR_T_DEFINED) ^^^
+
+#define _GENERIC_MATH_CLASSIFY1_RETV(FUN, RETV)                         \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, signed char)        \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned char)      \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, short)              \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned short)     \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, int)                \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned int)       \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, long)               \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned long)      \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, long long)          \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, unsigned long long) \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, bool)               \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char)               \
+    _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T(FUN, RETV)                     \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char16_t)           \
+    _GENERIC_MATH_CLASSIFY1_RETV_INTEGER(FUN, RETV, char32_t)           \
+    _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T(FUN, RETV)
+
 // The following order matches N4950 [cmath.syn].
 _GENERIC_MATH1(acos)
 _GENERIC_MATH1(asin)
@@ -701,7 +781,12 @@ _GENERIC_MATH2(fmax)
 _GENERIC_MATH2(fmin)
 // fma() is hand-crafted
 // lerp() is hand-crafted
-// The "classification/comparison functions" (fpclassify(), etc.) are exempt, LWG-1327
+// fpclassify() is hand-crafted
+_GENERIC_MATH_CLASSIFY1_RETV(isfinite, true)
+_GENERIC_MATH_CLASSIFY1_RETV(isinf, false)
+_GENERIC_MATH_CLASSIFY1_RETV(isnan, false)
+// isnormal() is half-hand-crafted
+// signbit() is hand-crafted
 
 #undef _GENERIC_MATH1_BASE
 #undef _GENERIC_MATH1R
@@ -711,6 +796,10 @@ _GENERIC_MATH2(fmin)
 #undef _GENERIC_MATH2_BASE
 #undef _GENERIC_MATH2
 #undef _GENERIC_MATH2I
+#undef _GENERIC_MATH_CLASSIFY1_RETV_INTEGER
+#undef _GENERIC_MATH_CLASSIFY1_RETV_WCHAR_T
+#undef _GENERIC_MATH_CLASSIFY1_RETV_CHAR8_T
+#undef _GENERIC_MATH_CLASSIFY1_RETV
 #undef _HAS_CMATH_INTRINSICS
 _END_EXTERN_CXX_WORKAROUND
 
diff --git a/tests/libcxx/expected_results.txt b/tests/libcxx/expected_results.txt
index ba26ae5bc1f..5211f2ab232 100644
--- a/tests/libcxx/expected_results.txt
+++ b/tests/libcxx/expected_results.txt
@@ -484,10 +484,6 @@ std/utilities/expected/expected.void/equality/equality.other_expected.pass.cpp:2
 
 
 # *** STL BUGS ***
-# GH-519 <cmath>: signbit() misses overloads for integer types
-std/depr/depr.c.headers/math_h.pass.cpp FAIL
-std/numerics/c.math/cmath.pass.cpp FAIL
-
 # GH-784 <type_traits>: aligned_storage has incorrect alignment defaults
 std/utilities/meta/meta.trans/meta.trans.other/aligned_storage.pass.cpp FAIL
 
diff --git a/tests/std/test.lst b/tests/std/test.lst
index cf8d9bf3ef1..a3ec79e1268 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -168,6 +168,7 @@ tests\GH_000431_lex_compare_family
 tests\GH_000431_lex_compare_memcmp_classify
 tests\GH_000442_random_subtract_with_carry_engine_io
 tests\GH_000457_system_error_message
+tests\GH_000519_cmath_int_overloads
 tests\GH_000527_remove_allocator_void
 tests\GH_000545_include_compare
 tests\GH_000625_vector_bool_optimization
diff --git a/tests/std/tests/GH_000519_cmath_int_overloads/env.lst b/tests/std/tests/GH_000519_cmath_int_overloads/env.lst
new file mode 100644
index 00000000000..19f025bd0e6
--- /dev/null
+++ b/tests/std/tests/GH_000519_cmath_int_overloads/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_matrix.lst
diff --git a/tests/std/tests/GH_000519_cmath_int_overloads/test.cpp b/tests/std/tests/GH_000519_cmath_int_overloads/test.cpp
new file mode 100644
index 00000000000..8954620c506
--- /dev/null
+++ b/tests/std/tests/GH_000519_cmath_int_overloads/test.cpp
@@ -0,0 +1,190 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#include <cassert>
+#include <cmath>
+#include <math.h>
+#include <type_traits>
+
+// Also test the partial implementation of P0533R9 "constexpr For <cmath> And <cstdlib>"
+#if _HAS_CXX23
+#define CONSTEXPR23 constexpr
+#else // ^^^ _HAS_CXX23 / !_HAS_CXX23 vvv
+#define CONSTEXPR23 inline
+#endif // ^^^ !_HAS_CXX23 ^^^
+
+CONSTEXPR23 void test_bool_overloads() {
+    // test overloads in std
+
+    assert(std::fpclassify(false) == FP_ZERO);
+    assert(std::fpclassify(true) == FP_NORMAL);
+
+    assert(std::isfinite(false));
+    assert(std::isfinite(true));
+
+    assert(!std::isinf(false));
+    assert(!std::isinf(true));
+
+    assert(!std::isnan(false));
+    assert(!std::isnan(true));
+
+    assert(!std::isnormal(false));
+    assert(std::isnormal(true));
+
+    assert(!std::signbit(false));
+    assert(!std::signbit(true));
+
+#if _HAS_CXX23 // TRANSITION, UCRT should implement P0533R9 "constexpr For <cmath> And <cstdlib>"
+    if (!std::is_constant_evaluated())
+#endif // ^^^ _HAS_CXX23 ^^^
+    {
+        assert(!std::isgreater(false, true));
+        assert(!std::isgreaterequal(false, true));
+        assert(std::isless(false, true));
+        assert(std::islessequal(false, true));
+        assert(std::islessgreater(false, true));
+        assert(!std::isunordered(false, true));
+    }
+
+    // test overloads in the global namespace
+
+    assert(::fpclassify(false) == FP_ZERO);
+    assert(::fpclassify(true) == FP_NORMAL);
+
+    assert(::isfinite(false));
+    assert(::isfinite(true));
+
+    assert(!::isinf(false));
+    assert(!::isinf(true));
+
+    assert(!::isnan(false));
+    assert(!::isnan(true));
+
+    assert(!::isnormal(false));
+    assert(::isnormal(true));
+
+    assert(!::signbit(false));
+    assert(!::signbit(true));
+
+#if _HAS_CXX23 // TRANSITION, UCRT should implement P0533R9 "constexpr For <cmath> And <cstdlib>"
+    if (!std::is_constant_evaluated())
+#endif // ^^^ _HAS_CXX23 ^^^
+    {
+        assert(!::isgreater(false, true));
+        assert(!::isgreaterequal(false, true));
+        assert(::isless(false, true));
+        assert(::islessequal(false, true));
+        assert(::islessgreater(false, true));
+        assert(!::isunordered(false, true));
+    }
+}
+
+template <class I>
+CONSTEXPR23 void test_other_integral_overloads() {
+    // test overloads in std
+
+    assert(std::fpclassify(I{}) == FP_ZERO);
+    assert(std::fpclassify(static_cast<I>(42)) == FP_NORMAL);
+    assert(std::fpclassify(static_cast<I>(-42)) == FP_NORMAL);
+
+    assert(std::isfinite(I{}));
+    assert(std::isfinite(static_cast<I>(42)));
+    assert(std::isfinite(static_cast<I>(-42)));
+
+    assert(!std::isinf(I{}));
+    assert(!std::isinf(static_cast<I>(42)));
+    assert(!std::isinf(static_cast<I>(-42)));
+
+    assert(!std::isnan(I{}));
+    assert(!std::isnan(static_cast<I>(42)));
+    assert(!std::isnan(static_cast<I>(-42)));
+
+    assert(!std::isnormal(I{}));
+    assert(std::isnormal(static_cast<I>(42)));
+    assert(std::isnormal(static_cast<I>(-42)));
+
+    assert(!std::signbit(I{}));
+    assert(!std::signbit(static_cast<I>(42)));
+    assert(std::signbit(static_cast<I>(-42)) == std::is_signed_v<I>);
+
+#if _HAS_CXX23 // TRANSITION, UCRT should implement P0533R9 "constexpr For <cmath> And <cstdlib>"
+    if (!std::is_constant_evaluated())
+#endif // ^^^ _HAS_CXX23 ^^^
+    {
+        assert(!std::isgreater(static_cast<I>(17), static_cast<I>(29)));
+        assert(!std::isgreaterequal(static_cast<I>(17), static_cast<I>(29)));
+        assert(std::isless(static_cast<I>(17), static_cast<I>(29)));
+        assert(std::islessequal(static_cast<I>(17), static_cast<I>(29)));
+        assert(std::islessgreater(static_cast<I>(17), static_cast<I>(29)));
+        assert(!std::isunordered(static_cast<I>(17), static_cast<I>(29)));
+    }
+
+    // test overloads in the global namespace
+
+    assert(::fpclassify(I{}) == FP_ZERO);
+    assert(::fpclassify(static_cast<I>(42)) == FP_NORMAL);
+    assert(::fpclassify(static_cast<I>(-42)) == FP_NORMAL);
+
+    assert(::isfinite(I{}));
+    assert(::isfinite(static_cast<I>(42)));
+    assert(::isfinite(static_cast<I>(-42)));
+
+    assert(!::isinf(I{}));
+    assert(!::isinf(static_cast<I>(42)));
+    assert(!::isinf(static_cast<I>(-42)));
+
+    assert(!::isnan(I{}));
+    assert(!::isnan(static_cast<I>(42)));
+    assert(!::isnan(static_cast<I>(-42)));
+
+    assert(!::isnormal(I{}));
+    assert(::isnormal(static_cast<I>(42)));
+    assert(::isnormal(static_cast<I>(-42)));
+
+    assert(!::signbit(I{}));
+    assert(!::signbit(static_cast<I>(42)));
+    assert(::signbit(static_cast<I>(-42)) == std::is_signed_v<I>);
+
+#if _HAS_CXX23 // TRANSITION, UCRT should implement P0533R9 "constexpr For <cmath> And <cstdlib>"
+    if (!std::is_constant_evaluated())
+#endif // ^^^ _HAS_CXX23 ^^^
+    {
+        assert(!::isgreater(static_cast<I>(17), static_cast<I>(29)));
+        assert(!::isgreaterequal(static_cast<I>(17), static_cast<I>(29)));
+        assert(::isless(static_cast<I>(17), static_cast<I>(29)));
+        assert(::islessequal(static_cast<I>(17), static_cast<I>(29)));
+        assert(::islessgreater(static_cast<I>(17), static_cast<I>(29)));
+        assert(!::isunordered(static_cast<I>(17), static_cast<I>(29)));
+    }
+}
+
+CONSTEXPR23 bool test_all_integral_overloads() {
+    test_bool_overloads();
+    test_other_integral_overloads<signed char>();
+    test_other_integral_overloads<unsigned char>();
+    test_other_integral_overloads<short>();
+    test_other_integral_overloads<unsigned short>();
+    test_other_integral_overloads<int>();
+    test_other_integral_overloads<unsigned int>();
+    test_other_integral_overloads<long>();
+    test_other_integral_overloads<unsigned long>();
+    test_other_integral_overloads<long long>();
+    test_other_integral_overloads<unsigned long long>();
+    test_other_integral_overloads<char>();
+#ifdef __cpp_char8_t
+    test_other_integral_overloads<char8_t>();
+#endif // defined(__cpp_char8_t)
+    test_other_integral_overloads<char16_t>();
+    test_other_integral_overloads<char32_t>();
+    test_other_integral_overloads<wchar_t>();
+
+    return true;
+}
+
+#if _HAS_CXX23
+static_assert(test_all_integral_overloads());
+#endif // _HAS_CXX23
+
+int main() {
+    test_all_integral_overloads();
+}

From 6410621f7a760009e1caf5013cd7d2f8c3726ed3 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 04:02:34 +0800
Subject: [PATCH 24/45] Implement LWG-4016 `container-insertable` checks do not
 match what `container-inserter` does (#4539)

---
 stl/inc/ranges                                |  37 +++--
 .../std/tests/P1206R7_ranges_to_misc/test.cpp | 139 ++++++++++++++++++
 2 files changed, 163 insertions(+), 13 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 37e9db92824..6cefcb07021 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -10328,27 +10328,26 @@ namespace ranges {
         && derived_from<typename iterator_traits<iterator_t<_Rng>>::iterator_category, input_iterator_tag>
         && constructible_from<_Container, iterator_t<_Rng>, iterator_t<_Rng>, _Types...>;
 
+    template <class _Container, class _Reference>
+    concept _Can_emplace_back = requires(_Container& _Cont) { _Cont.emplace_back(_STD declval<_Reference>()); };
+
     template <class _Container, class _Reference>
     concept _Can_push_back = requires(_Container& _Cont) { _Cont.push_back(_STD declval<_Reference>()); };
 
+    template <class _Container, class _Reference>
+    concept _Can_emplace_end = requires(_Container& _Cont) { _Cont.emplace(_Cont.end(), _STD declval<_Reference>()); };
+
     template <class _Container, class _Reference>
     concept _Can_insert_end = requires(_Container& _Cont) { _Cont.insert(_Cont.end(), _STD declval<_Reference>()); };
 
     template <class _Rng, class _Container, class... _Types>
-    concept _Converts_constructible_insertable =
+    concept _Converts_constructible_appendable =
         _Ref_converts<_Rng, _Container> && constructible_from<_Container, _Types...>
-        && (_Can_push_back<_Container, range_reference_t<_Rng>>
+        && (_Can_emplace_back<_Container, range_reference_t<_Rng>>
+            || _Can_push_back<_Container, range_reference_t<_Rng>>
+            || _Can_emplace_end<_Container, range_reference_t<_Rng>>
             || _Can_insert_end<_Container, range_reference_t<_Rng>>);
 
-    template <class _Reference, class _Container>
-    _NODISCARD constexpr auto _Container_inserter(_Container& _Cont) {
-        if constexpr (_Can_push_back<_Container, _Reference>) {
-            return back_insert_iterator{_Cont};
-        } else {
-            return insert_iterator{_Cont, _Cont.end()};
-        }
-    }
-
     _EXPORT_STD template <class _Container, input_range _Rng, class... _Types>
         requires (!view<_Container>)
     _NODISCARD constexpr _Container to(_Rng&& _Range, _Types&&... _Args) {
@@ -10361,12 +10360,24 @@ namespace ranges {
             return _Container(from_range, _STD forward<_Rng>(_Range), _STD forward<_Types>(_Args)...);
         } else if constexpr (_Converts_and_common_constructible<_Rng, _Container, _Types...>) {
             return _Container(_RANGES begin(_Range), _RANGES end(_Range), _STD forward<_Types>(_Args)...);
-        } else if constexpr (_Converts_constructible_insertable<_Rng, _Container, _Types...>) {
+        } else if constexpr (_Converts_constructible_appendable<_Rng, _Container, _Types...>) {
             _Container _Cont(_STD forward<_Types>(_Args)...);
             if constexpr (_Sized_and_reservable<_Rng, _Container>) {
                 _Cont.reserve(static_cast<range_size_t<_Container>>(_RANGES size(_Range)));
             }
-            _RANGES copy(_Range, _Container_inserter<range_reference_t<_Rng>>(_Cont));
+            for (auto&& _Elem : _Range) {
+                using _ElemTy = decltype(_Elem);
+                if constexpr (_Can_emplace_back<_Container, _ElemTy>) {
+                    _Cont.emplace_back(_STD forward<_ElemTy>(_Elem));
+                } else if constexpr (_Can_push_back<_Container, _ElemTy>) {
+                    _Cont.push_back(_STD forward<_ElemTy>(_Elem));
+                } else if constexpr (_Can_emplace_end<_Container, _ElemTy>) {
+                    _Cont.emplace(_Cont.end(), _STD forward<_ElemTy>(_Elem));
+                } else {
+                    _STL_INTERNAL_STATIC_ASSERT(_Can_insert_end<_Container, _ElemTy>);
+                    _Cont.insert(_Cont.end(), _STD forward<_ElemTy>(_Elem));
+                }
+            }
             return _Cont;
         } else if constexpr (!_Ref_converts<_Rng, _Container> && input_range<range_reference_t<_Rng>>) {
             const auto _Xform = [](auto&& _Elem) _STATIC_CALL_OPERATOR {
diff --git a/tests/std/tests/P1206R7_ranges_to_misc/test.cpp b/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
index 8e4e7ece696..0e433f419a4 100644
--- a/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_misc/test.cpp
@@ -1,10 +1,13 @@
 // Copyright (c) Microsoft Corporation.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
+#include <algorithm>
 #include <cassert>
 #include <cstddef>
+#include <memory>
 #include <optional>
 #include <ranges>
+#include <utility>
 #include <vector>
 
 namespace ranges = std::ranges;
@@ -200,6 +203,139 @@ constexpr bool test_lwg3785() {
     return true;
 }
 
+enum class restriction_kind {
+    emplace_back,
+    push_back,
+    emplace,
+    insert,
+};
+
+template <restriction_kind K, class T, class A = std::allocator<T>>
+class restricted_vector : private std::vector<T, A> {
+private:
+    using base_type = std::vector<T, A>;
+
+public:
+    using typename base_type::allocator_type;
+    using typename base_type::const_iterator;
+    using typename base_type::const_reverse_iterator;
+    using typename base_type::difference_type;
+    using typename base_type::iterator;
+    using typename base_type::pointer;
+    using typename base_type::reference;
+    using typename base_type::reverse_iterator;
+    using typename base_type::size_type;
+    using typename base_type::value_type;
+
+    restricted_vector() = default;
+    constexpr explicit restricted_vector(const A& alloc) noexcept : base_type(alloc) {}
+    constexpr explicit restricted_vector(const size_type n, const A& alloc = A()) : base_type(n, alloc) {}
+    constexpr restricted_vector(const size_type n, const T& val, const A& alloc = A()) : base_type(n, val, alloc) {}
+    constexpr restricted_vector(const std::initializer_list<T> il, const A& alloc = A()) : base_type(il, alloc) {}
+    constexpr restricted_vector(const restricted_vector& other, const A& alloc) : base_type(other, alloc) {}
+    constexpr restricted_vector(restricted_vector&& other, const A& alloc) noexcept(
+        std::allocator_traits<A>::is_always_equal::value)
+        : base_type(std::move(other), alloc) {}
+
+    using base_type::begin;
+    using base_type::cbegin;
+    using base_type::cend;
+    using base_type::crbegin;
+    using base_type::crend;
+    using base_type::end;
+    using base_type::rbegin;
+    using base_type::rend;
+
+    using base_type::back;
+    using base_type::front;
+    using base_type::operator[];
+    using base_type::at;
+    using base_type::data;
+
+    template <class... Args>
+    constexpr T& emplace_back(Args&&... args)
+        requires (K == restriction_kind::emplace_back)
+    {
+        return base_type::emplace_back(std::forward<Args>(args)...);
+    }
+
+    constexpr void push_back(const T& t)
+        requires (K == restriction_kind::push_back)
+    {
+        base_type::emplace_back(t);
+    }
+    constexpr void push_back(T&& t)
+        requires (K == restriction_kind::push_back)
+    {
+        base_type::emplace_back(std::move(t));
+    }
+
+    template <class... Args>
+    constexpr iterator emplace(const const_iterator it, Args&&... args)
+        requires (K == restriction_kind::emplace)
+    {
+        return base_type::emplace(it, std::forward<Args>(args)...);
+    }
+
+    constexpr iterator insert(const const_iterator it, const T& t)
+        requires (K == restriction_kind::insert)
+    {
+        return base_type::emplace(it, t);
+    }
+    constexpr iterator insert(const const_iterator it, T&& t)
+        requires (K == restriction_kind::insert)
+    {
+        return base_type::emplace(it, std::move(t));
+    }
+};
+
+template <restriction_kind K>
+constexpr void test_lwg4016_per_kind() {
+    using V = restricted_vector<K, int>;
+    {
+        std::same_as<V> auto vec = std::views::iota(0, 42) | ranges::to<V>();
+        assert(ranges::equal(vec, std::views::iota(0, 42)));
+    }
+    {
+        std::same_as<V> auto vec = std::views::iota(0, 42) | ranges::to<V>(std::allocator<int>{});
+        assert(ranges::equal(vec, std::views::iota(0, 42)));
+    }
+    {
+        std::same_as<V> auto vec = std::views::empty<int> | ranges::to<V>(std::size_t{42});
+        assert(ranges::equal(vec, std::views::repeat(0, 42)));
+    }
+    {
+        std::same_as<V> auto vec = std::views::empty<int> | ranges::to<V>(std::size_t{42}, std::allocator<int>{});
+        assert(ranges::equal(vec, std::views::repeat(0, 42)));
+    }
+    {
+        std::same_as<V> auto vec = ranges::to<V>(std::views::iota(0, 42), std::initializer_list<int>{-3, -2, -1});
+        assert(ranges::equal(vec, std::views::iota(-3, 42)));
+    }
+    {
+        std::same_as<V> auto vec =
+            ranges::to<V>(std::views::iota(0, 42), std::initializer_list<int>{-3, -2, -1}, std::allocator<int>{});
+        assert(ranges::equal(vec, std::views::iota(-3, 42)));
+    }
+    {
+        std::same_as<V> auto vec = ranges::to<V>(std::views::iota(0, 42), V{-3, -2, -1}, std::allocator<int>{});
+        assert(ranges::equal(vec, std::views::iota(-3, 42)));
+    }
+    {
+        V vec0{1, 2, 3};
+        std::same_as<V> auto vec = ranges::to<V>(std::views::iota(4, 7), vec0, std::allocator<int>{});
+        assert(ranges::equal(vec, std::views::iota(1, 7)));
+    }
+}
+
+constexpr bool test_lwg4016() {
+    test_lwg4016_per_kind<restriction_kind::emplace_back>();
+    test_lwg4016_per_kind<restriction_kind::push_back>();
+    test_lwg4016_per_kind<restriction_kind::emplace>();
+    test_lwg4016_per_kind<restriction_kind::insert>();
+    return true;
+}
+
 int main() {
     test_reservable();
     static_assert(test_reservable());
@@ -217,4 +353,7 @@ int main() {
 
     test_lwg3785();
     static_assert(test_lwg3785());
+
+    test_lwg4016();
+    static_assert(test_lwg4016());
 }

From 06b286c6dd37788a99fcbc6a75e76d9ba1d3a9a6 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 04:05:45 +0800
Subject: [PATCH 25/45] Implement LWG-4054 Repeating a `repeat_view` should
 repeat the view (#4540)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/ranges                                | 6 +++---
 tests/std/tests/P2474R2_views_repeat/test.cpp | 9 +++++++--
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 6cefcb07021..d0842e1a6a2 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -1705,10 +1705,10 @@ namespace ranges {
         struct _Repeat_fn {
             template <class _Ty>
             _NODISCARD _STATIC_CALL_OPERATOR constexpr auto operator()(_Ty&& _Value) _CONST_CALL_OPERATOR
-                noexcept(noexcept(repeat_view(_STD forward<_Ty>(_Value))))
-                requires requires { repeat_view(_STD forward<_Ty>(_Value)); }
+                noexcept(noexcept(repeat_view<decay_t<_Ty>>(_STD forward<_Ty>(_Value))))
+                requires requires { repeat_view<decay_t<_Ty>>(_STD forward<_Ty>(_Value)); }
             {
-                return repeat_view(_STD forward<_Ty>(_Value));
+                return repeat_view<decay_t<_Ty>>(_STD forward<_Ty>(_Value));
             }
 
             template <class _Ty1, class _Ty2>
diff --git a/tests/std/tests/P2474R2_views_repeat/test.cpp b/tests/std/tests/P2474R2_views_repeat/test.cpp
index ed198b9ab03..c559b170407 100644
--- a/tests/std/tests/P2474R2_views_repeat/test.cpp
+++ b/tests/std/tests/P2474R2_views_repeat/test.cpp
@@ -363,14 +363,19 @@ constexpr bool test() {
     return true;
 }
 
-// Check LWG-3875
+// Check LWG-3875 "std::ranges::repeat_view<T, IntegerClass>::iterator may be ill-formed"
 static_assert(CanViewRepeat<string, long long>);
 static_assert(CanViewRepeat<string, unsigned long long>);
 static_assert(CanViewRepeat<string, _Signed128>);
 static_assert(
     !CanViewRepeat<string, _Unsigned128>); // _Unsigned128 does not satisfy 'integer-like-with-usable-difference-type'
 
-// Check GH-3392
+// Check LWG-4054 "Repeating a repeat_view should repeat the view"
+static_assert(is_same_v<decltype(views::repeat(views::repeat(42))), ranges::repeat_view<ranges::repeat_view<int>>>);
+static_assert(is_same_v<decltype(views::repeat("Hello world!")), ranges::repeat_view<const char*>>);
+static_assert(is_same_v<decltype(views::repeat(test)), ranges::repeat_view<bool (*)()>>);
+
+// Check GH-3392 "<ranges>: views::repeat(...) | views::take(...) is not always a valid range"
 static_assert(ranges::range<decltype(views::repeat('3', 100ull) | views::take(3))>);
 static_assert(ranges::range<decltype(views::repeat('3', 100ull) | views::drop(3))>);
 

From 9465bb0dd620c6539d55466996c05f670e8544b7 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 04:08:08 +0800
Subject: [PATCH 26/45] Implement LWG-3767 `codecvt<charN_t, char8_t,
 mbstate_t>` incorrectly added to locale (#4542)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/xlocale                               | 79 ++++++++++++++++---
 stl/inc/yvals_core.h                          | 17 +++-
 .../Dev09_056375_locale_cleanup/test.cpp      |  1 +
 .../tests/VSO_0397980_codecvt_length/test.cpp |  1 +
 4 files changed, 85 insertions(+), 13 deletions(-)

diff --git a/stl/inc/xlocale b/stl/inc/xlocale
index 6a2f168ab72..2d47e75cdce 100644
--- a/stl/inc/xlocale
+++ b/stl/inc/xlocale
@@ -1397,7 +1397,7 @@ struct _NODISCARD _Codecvt_guard {
 };
 
 extern "C++" template <>
-class codecvt<char16_t, char8_t, mbstate_t> : public codecvt_base {
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt<char16_t, char8_t, mbstate_t> : public codecvt_base {
     // facet for converting between UTF-16 and UTF-8 sequences
 public:
     using intern_type = char16_t;
@@ -1678,7 +1678,7 @@ protected:
 };
 
 extern "C++" template <>
-class codecvt<char32_t, char8_t, mbstate_t> : public codecvt_base {
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt<char32_t, char8_t, mbstate_t> : public codecvt_base {
     // facet for converting between UTF-32 and UTF-8 sequences
 public:
     using intern_type = char32_t;
@@ -2321,26 +2321,85 @@ private:
 #endif // defined(_NATIVE_WCHAR_T_DEFINED) && !_ENFORCE_FACET_SPECIALIZATIONS
 
 _EXPORT_STD template <class _Elem, class _Byte, class _Statype>
-class codecvt_byname : public codecvt<_Elem, _Byte, _Statype> { // codecvt for named locale
+class codecvt_byname : public codecvt<_Elem, _Byte, _Statype> {
 public:
     static_assert(!_ENFORCE_FACET_SPECIALIZATIONS
-                      || _Is_any_of_v<codecvt_byname,
-#ifdef __cpp_char8_t
-                          codecvt_byname<char16_t, char8_t, mbstate_t>, codecvt_byname<char32_t, char8_t, mbstate_t>,
-#endif // defined(__cpp_char8_t)
-                          codecvt_byname<char, char, mbstate_t>, codecvt_byname<wchar_t, char, mbstate_t>>,
+                      || _Is_any_of_v<codecvt_byname, codecvt_byname<char, char, mbstate_t>,
+                          codecvt_byname<wchar_t, char, mbstate_t>>,
         _FACET_SPECIALIZATION_MESSAGE);
 
     explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
-        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Locname), _Refs) {} // construct for named locale
+        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+_STL_DISABLE_DEPRECATED_WARNING
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_FACETS codecvt_byname<char16_t, char, mbstate_t>
+    : public codecvt<char16_t, char, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+template <>
+class _CXX20_DEPRECATE_CODECVT_FACETS codecvt_byname<char32_t, char, mbstate_t>
+    : public codecvt<char32_t, char, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+
+#ifdef __cpp_char8_t
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt_byname<char16_t, char8_t, mbstate_t>
+    : public codecvt<char16_t, char8_t, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
 
     explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
-        : codecvt<_Elem, _Byte, _Statype>(_Locinfo(_Str.c_str()), _Refs) {} // construct for named locale
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
 
 protected:
     __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
 };
 
+template <>
+class _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS codecvt_byname<char32_t, char8_t, mbstate_t>
+    : public codecvt<char32_t, char8_t, mbstate_t> {
+public:
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const char* _Locname, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Locname), _Refs) {}
+
+    explicit __CLR_OR_THIS_CALL codecvt_byname(const string& _Str, size_t _Refs = 0)
+        : codecvt(_Locinfo(_Str.c_str()), _Refs) {}
+
+protected:
+    __CLR_OR_THIS_CALL ~codecvt_byname() noexcept override {}
+};
+#endif // defined(__cpp_char8_t)
+
+_STL_RESTORE_DEPRECATED_WARNING
+
 #define _XA 0x100 // extra alphabetic
 #define _BB _CONTROL // BEL, BS, etc.
 #define _CN _SPACE // CR, FF, HT, NL, VT
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index e027e322a9c..678341f07e9 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -1253,8 +1253,7 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
     [[deprecated("warning STL4020: "                                                                                   \
                  "std::codecvt<char16_t, char, mbstate_t>, std::codecvt<char32_t, char, mbstate_t>, "                  \
                  "std::codecvt_byname<char16_t, char, mbstate_t>, and std::codecvt_byname<char32_t, char, mbstate_t> " \
-                 "are deprecated in C++20 and replaced by specializations with a second argument of type char8_t. "    \
-                 "You can define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING "                                   \
+                 "are deprecated in C++20. You can define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING "          \
                  "or _SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
 #else // ^^^ warning enabled / warning disabled vvv
 #define _CXX20_DEPRECATE_CODECVT_FACETS
@@ -1514,7 +1513,19 @@ _EMIT_STL_ERROR(STL1004, "C++98 unexpected() is incompatible with C++23 unexpect
 #define _DEPRECATE_TR1_RANDOM
 #endif // ^^^ warning disabled ^^^
 
-// next warning number: STL4047
+#if _HAS_CXX20 && defined(__cpp_char8_t) && !defined(_SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING) \
+    && !defined(_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS)
+#define _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS                                                                     \
+    [[deprecated(                                                                                                   \
+        "warning STL4047: std::codecvt<char16_t, char8_t, mbstate_t>, std::codecvt<char32_t, char8_t, mbstate_t>, " \
+        "std::codecvt_byname<char16_t, char8_t, mbstate_t>, and std::codecvt_byname<char32_t, char8_t, mbstate_t> " \
+        "are deprecated by LWG-3767. You can define _SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING or "  \
+        "_SILENCE_ALL_CXX20_DEPRECATION_WARNINGS to suppress this warning.")]]
+#else // ^^^ warning enabled / warning disabled vvv
+#define _CXX20_DEPRECATE_CODECVT_CHAR8_T_FACETS
+#endif // ^^^ warning disabled ^^^
+
+// next warning number: STL4048
 
 // next error number: STL1006
 
diff --git a/tests/std/tests/Dev09_056375_locale_cleanup/test.cpp b/tests/std/tests/Dev09_056375_locale_cleanup/test.cpp
index 1fecfd287e3..02bbe0388cf 100644
--- a/tests/std/tests/Dev09_056375_locale_cleanup/test.cpp
+++ b/tests/std/tests/Dev09_056375_locale_cleanup/test.cpp
@@ -2,6 +2,7 @@
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 #define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING
+#define _SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING
 
 #include <cassert>
 #include <cstdio>
diff --git a/tests/std/tests/VSO_0397980_codecvt_length/test.cpp b/tests/std/tests/VSO_0397980_codecvt_length/test.cpp
index 7558dc5f4ec..9bcad7435f1 100644
--- a/tests/std/tests/VSO_0397980_codecvt_length/test.cpp
+++ b/tests/std/tests/VSO_0397980_codecvt_length/test.cpp
@@ -3,6 +3,7 @@
 
 #define _SILENCE_CXX17_CODECVT_HEADER_DEPRECATION_WARNING
 #define _SILENCE_CXX20_CODECVT_FACETS_DEPRECATION_WARNING
+#define _SILENCE_CXX20_CODECVT_CHAR8_T_FACETS_DEPRECATION_WARNING
 
 #undef _ENFORCE_FACET_SPECIALIZATIONS
 #define _ENFORCE_FACET_SPECIALIZATIONS 0

From 391e7b4db298088c700f4f23b6b655040f5e4843 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 04:10:10 +0800
Subject: [PATCH 27/45] Implement LWG-3984 `ranges::to`'s recursion branch may
 be ill-formed (#4543)

---
 stl/inc/ranges                                      |  2 +-
 tests/std/tests/P1206R7_ranges_to_sequence/test.cpp | 11 +++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/stl/inc/ranges b/stl/inc/ranges
index d0842e1a6a2..620930cc047 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -10383,7 +10383,7 @@ namespace ranges {
             const auto _Xform = [](auto&& _Elem) _STATIC_CALL_OPERATOR {
                 return _RANGES to<range_value_t<_Container>>(_STD forward<decltype(_Elem)>(_Elem));
             };
-            return _RANGES to<_Container>(views::transform(_Range, _Xform), _STD forward<_Types>(_Args)...);
+            return _RANGES to<_Container>(views::transform(ref_view{_Range}, _Xform), _STD forward<_Types>(_Args)...);
         } else {
             static_assert(_Always_false<_Container>, "the program is ill-formed per N4950 [range.utility.conv.to]/2.3");
         }
diff --git a/tests/std/tests/P1206R7_ranges_to_sequence/test.cpp b/tests/std/tests/P1206R7_ranges_to_sequence/test.cpp
index e3032e3fe1b..9ee7894d9f7 100644
--- a/tests/std/tests/P1206R7_ranges_to_sequence/test.cpp
+++ b/tests/std/tests/P1206R7_ranges_to_sequence/test.cpp
@@ -57,6 +57,11 @@ struct sequence_instantiator {
     template <template <class...> class C, class T, class... Args>
     using deduce_container = deduce_container_impl<C>::template apply<T, Args...>;
 
+    template <class>
+    static constexpr bool is_basic_string = false;
+    template <class CharT, class Traits, class Alloc>
+    static constexpr bool is_basic_string<std::basic_string<CharT, Traits, Alloc>> = true;
+
     static constexpr auto meow = "meow"sv;
 
     template <template <class...> class C>
@@ -96,6 +101,12 @@ struct sequence_instantiator {
             std::same_as<C<char>> auto c7 = c | ranges::to<C>();
             assert(c7 == c);
         }
+        if constexpr (!is_basic_string<C<char>>) { // LWG-3984 "ranges::to's recursion branch may be ill-formed"
+            auto owning                     = std::views::all(C<C<char>>{c});
+            std::same_as<C<C<int>>> auto c8 = owning | ranges::to<C<C<int>>>();
+            assert(
+                ranges::equal(c8, C<C<char>>{c}, [](const auto& r1, const auto& r2) { return ranges::equal(r1, r2); }));
+        }
 
         return true;
     }

From d3c435b3d1c8c199d4da97de1ab8781dab0fca66 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Tue, 9 Apr 2024 23:51:16 +0300
Subject: [PATCH 28/45] Standardize vector algorithms dispatch (#4544)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/algorithm             |  95 ++++++++++++---------------
 stl/inc/xutility              |  82 +++++++++++++----------
 stl/src/vector_algorithms.cpp | 118 +++++++++++++++++-----------------
 3 files changed, 150 insertions(+), 145 deletions(-)

diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index ff1f8b65e3c..29672ceb0ff 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -76,8 +76,23 @@ __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, cons
 } // extern "C"
 
 _STD_BEGIN
+template <size_t _Nx>
+__declspec(noalias) void _Reverse_copy_vectorized(const void* _First, const void* _Last, void* _Dest) {
+    if constexpr (_Nx == 1) {
+        ::__std_reverse_copy_trivially_copyable_1(_First, _Last, _Dest);
+    } else if constexpr (_Nx == 2) {
+        ::__std_reverse_copy_trivially_copyable_2(_First, _Last, _Dest);
+    } else if constexpr (_Nx == 4) {
+        ::__std_reverse_copy_trivially_copyable_4(_First, _Last, _Dest);
+    } else if constexpr (_Nx == 8) {
+        ::__std_reverse_copy_trivially_copyable_8(_First, _Last, _Dest);
+    } else {
+        static_assert(_Always_false<integral_constant<size_t, _Nx>>, "Unexpected size");
+    }
+}
+
 template <class _Ty>
-pair<_Ty*, _Ty*> __std_minmax_element(_Ty* const _First, _Ty* const _Last) noexcept {
+pair<_Ty*, _Ty*> _Minmax_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
 
     _Min_max_element_t _Res;
@@ -102,7 +117,7 @@ pair<_Ty*, _Ty*> __std_minmax_element(_Ty* const _First, _Ty* const _Last) noexc
 }
 
 template <class _Ty>
-auto __std_minmax(_Ty* const _First, _Ty* const _Last) noexcept {
+auto _Minmax_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
 
     if constexpr (is_pointer_v<_Ty>) {
@@ -146,9 +161,15 @@ auto __std_minmax(_Ty* const _First, _Ty* const _Last) noexcept {
 }
 
 template <class _Ty, class _TVal>
-_Ty* __std_find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+_Ty* _Find_last_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
     if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) {
-        return _STD __std_find_last_trivial(_First, _Last, reinterpret_cast<uintptr_t>(_Val));
+#ifdef _WIN64
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_last_trivial_8(_First, _Last, reinterpret_cast<uint64_t>(_Val))));
+#else
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_last_trivial_4(_First, _Last, reinterpret_cast<uint32_t>(_Val))));
+#endif
     } else if constexpr (sizeof(_Ty) == 1) {
         return const_cast<_Ty*>(
             static_cast<const _Ty*>(::__std_find_last_trivial_1(_First, _Last, static_cast<uint8_t>(_Val))));
@@ -167,7 +188,7 @@ _Ty* __std_find_last_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _V
 }
 
 template <class _Ty1, class _Ty2>
-_Ty1* __std_find_first_of_trivial(
+_Ty1* _Find_first_of_vectorized(
     _Ty1* const _First1, _Ty1* const _Last1, _Ty2* const _First2, _Ty2* const _Last2) noexcept {
     if constexpr (sizeof(_Ty1) == 1) {
         return const_cast<_Ty1*>(
@@ -578,7 +599,7 @@ namespace ranges {
                     const auto _First_ptr = _STD _To_address(_First);
                     const auto _Last_ptr  = _First_ptr + (_Last - _First);
 
-                    return static_cast<iter_difference_t<_It>>(_STD __std_count_trivial(_First_ptr, _Last_ptr, _Val));
+                    return static_cast<iter_difference_t<_It>>(_STD _Count_vectorized(_First_ptr, _Last_ptr, _Val));
                 }
             }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -674,7 +695,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(_InIt1 _First1, const _InI
         if (!_STD _Is_constant_evaluated()) {
             constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>);
 
-            const size_t _Pos = _STD __std_mismatch<_Elem_size>(
+            const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
                 _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast<size_t>(_ULast1 - _UFirst1));
 
             _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos);
@@ -738,7 +759,7 @@ _NODISCARD _CONSTEXPR20 pair<_InIt1, _InIt2> mismatch(
             if (!_STD _Is_constant_evaluated()) {
                 constexpr size_t _Elem_size = sizeof(_Iter_value_t<_InIt1>);
 
-                const size_t _Pos = _STD __std_mismatch<_Elem_size>(
+                const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
                     _STD _To_address(_UFirst1), _STD _To_address(_UFirst2), static_cast<size_t>(_Count));
 
                 _UFirst1 += static_cast<_Iter_diff_t<_InIt1>>(_Pos);
@@ -2976,7 +2997,7 @@ namespace ranges {
                     const auto _First_ptr = _STD _To_address(_First);
                     const auto _Last_ptr  = _First_ptr + _Count;
 
-                    const auto _Result = _STD __std_find_last_trivial(_First_ptr, _Last_ptr, _Value);
+                    const auto _Result = _STD _Find_last_vectorized(_First_ptr, _Last_ptr, _Value);
                     if constexpr (is_pointer_v<_It>) {
                         return {_Result, _Last_ptr};
                     } else {
@@ -3387,7 +3408,7 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(
     if constexpr (_Vector_alg_in_find_first_of_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
         if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) {
             const auto _First1_ptr = _STD _To_address(_UFirst1);
-            const auto _Result     = _STD __std_find_first_of_trivial(
+            const auto _Result     = _STD _Find_first_of_vectorized(
                     _First1_ptr, _STD _To_address(_ULast1), _STD _To_address(_UFirst2), _STD _To_address(_ULast2));
 
             if constexpr (is_pointer_v<decltype(_UFirst1)>) {
@@ -3491,7 +3512,7 @@ namespace ranges {
                     const auto _Last2_ptr  = _First2_ptr + _Count2;
 
                     const auto _Result =
-                        _STD __std_find_first_of_trivial(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr);
+                        _STD _Find_first_of_vectorized(_First1_ptr, _Last1_ptr, _First2_ptr, _Last2_ptr);
 
                     if constexpr (is_pointer_v<_It1>) {
                         return _Result;
@@ -4919,18 +4940,7 @@ namespace ranges {
 
             if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
                 if (!_STD is_constant_evaluated()) {
-                    _Elem* const _First_addr = _STD to_address(_First);
-                    _Elem* const _Last_addr  = _STD to_address(_Last);
-                    if constexpr (_Nx == 1) {
-                        ::__std_reverse_trivially_swappable_1(_First_addr, _Last_addr);
-                    } else if constexpr (_Nx == 2) {
-                        ::__std_reverse_trivially_swappable_2(_First_addr, _Last_addr);
-                    } else if constexpr (_Nx == 4) {
-                        ::__std_reverse_trivially_swappable_4(_First_addr, _Last_addr);
-                    } else {
-                        ::__std_reverse_trivially_swappable_8(_First_addr, _Last_addr);
-                    }
-
+                    _STD _Reverse_vectorized<_Nx>(_STD to_address(_First), _STD to_address(_Last));
                     return;
                 }
             }
@@ -4989,20 +4999,8 @@ _CONSTEXPR20 _OutIt reverse_copy(_BidIt _First, _BidIt _Last, _OutIt _Dest) {
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            if constexpr (_Nx == 1) {
-                ::__std_reverse_copy_trivially_copyable_1(
-                    _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest));
-            } else if constexpr (_Nx == 2) {
-                ::__std_reverse_copy_trivially_copyable_2(
-                    _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest));
-            } else if constexpr (_Nx == 4) {
-                ::__std_reverse_copy_trivially_copyable_4(
-                    _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest));
-            } else {
-                ::__std_reverse_copy_trivially_copyable_8(
-                    _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest));
-            }
-
+            _STD _Reverse_copy_vectorized<_Nx>(
+                _STD _To_address(_UFirst), _STD _To_address(_ULast), _STD _To_address(_UDest));
             _UDest += _ULast - _UFirst;
             _STD _Seek_wrapped(_Dest, _UDest);
             return _Dest;
@@ -5078,19 +5076,8 @@ namespace ranges {
 
                 if constexpr (_Allow_vectorization && _Nx <= 8 && (_Nx & (_Nx - 1)) == 0) {
                     if (!_STD is_constant_evaluated()) {
-                        _Elem* const _First_addr      = _STD to_address(_First);
-                        _Elem* const _Last_addr       = _STD to_address(_Last);
-                        _DestElem* const _Result_addr = _STD to_address(_Result);
-                        if constexpr (_Nx == 1) {
-                            ::__std_reverse_copy_trivially_copyable_1(_First_addr, _Last_addr, _Result_addr);
-                        } else if constexpr (_Nx == 2) {
-                            ::__std_reverse_copy_trivially_copyable_2(_First_addr, _Last_addr, _Result_addr);
-                        } else if constexpr (_Nx == 4) {
-                            ::__std_reverse_copy_trivially_copyable_4(_First_addr, _Last_addr, _Result_addr);
-                        } else {
-                            ::__std_reverse_copy_trivially_copyable_8(_First_addr, _Last_addr, _Result_addr);
-                        }
-
+                        _STD _Reverse_copy_vectorized<_Nx>(
+                            _STD to_address(_First), _STD to_address(_Last), _STD to_address(_Result));
                         _Result += _Last - _First;
                         return _Result;
                     }
@@ -10049,7 +10036,7 @@ constexpr pair<_FwdIt, _FwdIt> _Minmax_element_unchecked(_FwdIt _First, _FwdIt _
     if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
         if (!_Is_constant_evaluated()) {
             const auto _First_ptr = _STD _To_address(_First);
-            const auto _Result    = _STD __std_minmax_element(_First_ptr, _STD _To_address(_Last));
+            const auto _Result    = _STD _Minmax_element_vectorized(_First_ptr, _STD _To_address(_Last));
             if constexpr (is_pointer_v<_FwdIt>) {
                 return _Result;
             } else {
@@ -10176,7 +10163,7 @@ namespace ranges {
                 if (!_STD is_constant_evaluated()) {
                     const auto _First_ptr = _STD to_address(_First);
                     const auto _Last_ptr  = _First_ptr + (_Last - _First);
-                    const auto _Result    = _STD __std_minmax_element(_First_ptr, _Last_ptr);
+                    const auto _Result    = _STD _Minmax_element_vectorized(_First_ptr, _Last_ptr);
                     if constexpr (is_pointer_v<_It>) {
                         return {_Result.first, _Result.second};
                     } else {
@@ -10254,7 +10241,7 @@ _NODISCARD constexpr pair<_Ty, _Ty> minmax(initializer_list<_Ty> _Ilist, _Pr _Pr
 #if _USE_STD_VECTOR_ALGORITHMS
     if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
         if (!_STD _Is_constant_evaluated()) {
-            const auto _Result = _STD __std_minmax(_Ilist.begin(), _Ilist.end());
+            const auto _Result = _STD _Minmax_vectorized(_Ilist.begin(), _Ilist.end());
             return {static_cast<_Ty>(_Result._Min), static_cast<_Ty>(_Result._Max)};
         }
     }
@@ -10386,7 +10373,7 @@ namespace ranges {
                 if (!_STD is_constant_evaluated()) {
                     const auto _First_ptr = _STD to_address(_First);
                     const auto _Last_ptr  = _First_ptr + (_Last - _First);
-                    const auto _Result    = _STD __std_minmax(_First_ptr, _Last_ptr);
+                    const auto _Result    = _STD _Minmax_vectorized(_First_ptr, _Last_ptr);
                     return {static_cast<_Vty>(_Result._Min), static_cast<_Vty>(_Result._Max)};
                 }
             }
diff --git a/stl/inc/xutility b/stl/inc/xutility
index f2e0482894a..6e960212172 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -132,10 +132,29 @@ __declspec(noalias) size_t __stdcall __std_mismatch_8(const void* _First1, const
 } // extern "C"
 
 _STD_BEGIN
+template <size_t _Nx>
+__declspec(noalias) void _Reverse_vectorized(void* _First, void* _Last) noexcept {
+    if constexpr (_Nx == 1) {
+        ::__std_reverse_trivially_swappable_1(_First, _Last);
+    } else if constexpr (_Nx == 2) {
+        ::__std_reverse_trivially_swappable_2(_First, _Last);
+    } else if constexpr (_Nx == 4) {
+        ::__std_reverse_trivially_swappable_4(_First, _Last);
+    } else if constexpr (_Nx == 8) {
+        ::__std_reverse_trivially_swappable_8(_First, _Last);
+    } else {
+        static_assert(_Always_false<integral_constant<size_t, _Nx>>, "Unexpected size");
+    }
+}
+
 template <class _Ty, class _TVal>
-__declspec(noalias) size_t __std_count_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+__declspec(noalias) size_t _Count_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
     if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) {
-        return _STD __std_count_trivial(_First, _Last, reinterpret_cast<uintptr_t>(_Val));
+#ifdef _WIN64
+        return ::__std_count_trivial_8(_First, _Last, reinterpret_cast<uint64_t>(_Val));
+#else
+        return ::__std_count_trivial_4(_First, _Last, reinterpret_cast<uint32_t>(_Val));
+#endif
     } else if constexpr (sizeof(_Ty) == 1) {
         return ::__std_count_trivial_1(_First, _Last, static_cast<uint8_t>(_Val));
     } else if constexpr (sizeof(_Ty) == 2) {
@@ -150,9 +169,15 @@ __declspec(noalias) size_t __std_count_trivial(_Ty* const _First, _Ty* const _La
 }
 
 template <class _Ty, class _TVal>
-_Ty* __std_find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
+_Ty* _Find_vectorized(_Ty* const _First, _Ty* const _Last, const _TVal _Val) noexcept {
     if constexpr (is_pointer_v<_TVal> || is_null_pointer_v<_TVal>) {
-        return _STD __std_find_trivial(_First, _Last, reinterpret_cast<uintptr_t>(_Val));
+#ifdef _WIN64
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_8(_First, _Last, reinterpret_cast<uint64_t>(_Val))));
+#else
+        return const_cast<_Ty*>(
+            static_cast<const _Ty*>(::__std_find_trivial_4(_First, _Last, reinterpret_cast<uint32_t>(_Val))));
+#endif
     } else if constexpr (sizeof(_Ty) == 1) {
         return const_cast<_Ty*>(
             static_cast<const _Ty*>(::__std_find_trivial_1(_First, _Last, static_cast<uint8_t>(_Val))));
@@ -171,7 +196,7 @@ _Ty* __std_find_trivial(_Ty* const _First, _Ty* const _Last, const _TVal _Val) n
 }
 
 template <class _Ty>
-_Ty* __std_min_element(_Ty* const _First, _Ty* const _Last) noexcept {
+_Ty* _Min_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
 
     if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
@@ -192,7 +217,7 @@ _Ty* __std_min_element(_Ty* const _First, _Ty* const _Last) noexcept {
 }
 
 template <class _Ty>
-_Ty* __std_max_element(_Ty* const _First, _Ty* const _Last) noexcept {
+_Ty* _Max_element_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
 
     if constexpr (is_same_v<remove_const_t<_Ty>, float>) {
@@ -213,7 +238,7 @@ _Ty* __std_max_element(_Ty* const _First, _Ty* const _Last) noexcept {
 }
 
 template <class _Ty>
-auto __std_min(_Ty* const _First, _Ty* const _Last) noexcept {
+auto _Min_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
 
     if constexpr (is_pointer_v<_Ty>) {
@@ -256,7 +281,7 @@ auto __std_min(_Ty* const _First, _Ty* const _Last) noexcept {
 }
 
 template <class _Ty>
-auto __std_max(_Ty* const _First, _Ty* const _Last) noexcept {
+auto _Max_vectorized(_Ty* const _First, _Ty* const _Last) noexcept {
     constexpr bool _Signed = is_signed_v<_Ty>;
 
     if constexpr (is_pointer_v<_Ty>) {
@@ -300,7 +325,7 @@ auto __std_max(_Ty* const _First, _Ty* const _Last) noexcept {
 
 template <size_t _Element_size>
 inline size_t // TRANSITION, GH-4496
-    __std_mismatch(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
+    _Mismatch_vectorized(const void* const _First1, const void* const _First2, const size_t _Count) noexcept {
     if constexpr (_Element_size == 1) {
         return __std_mismatch_1(_First1, _First2, _Count);
     } else if constexpr (_Element_size == 2) {
@@ -5504,7 +5529,7 @@ namespace ranges {
             if (!_STD is_constant_evaluated()) {
                 constexpr size_t _Elem_size = sizeof(iter_value_t<_It1>);
 
-                const size_t _Pos = _STD __std_mismatch<_Elem_size>(
+                const size_t _Pos = _STD _Mismatch_vectorized<_Elem_size>(
                     _STD _To_address(_First1), _STD _To_address(_First2), static_cast<size_t>(_Count));
 
                 return {_First1 + static_cast<iter_difference_t<_It1>>(_Pos),
@@ -5924,7 +5949,7 @@ _NODISCARD _CONSTEXPR20 _InIt _Find_unchecked(_InIt _First, const _InIt _Last, c
             }
 #if _USE_STD_VECTOR_ALGORITHMS
             const auto _First_ptr = _STD _To_address(_First);
-            const auto _Result    = _STD __std_find_trivial(_First_ptr, _STD _To_address(_Last), _Val);
+            const auto _Result    = _STD _Find_vectorized(_First_ptr, _STD _To_address(_Last), _Val);
             if constexpr (is_pointer_v<_InIt>) {
                 return _Result;
             } else {
@@ -6011,7 +6036,7 @@ namespace ranges {
                 if constexpr (_Is_sized) {
                     // When _Is_sized && _Single_byte_elements, prefer this over memchr() for performance
                     const auto _Last_ptr = _First_ptr + (_Last - _First);
-                    _Result              = _STD __std_find_trivial(_First_ptr, _Last_ptr, _Val);
+                    _Result              = _STD _Find_vectorized(_First_ptr, _Last_ptr, _Val);
                 } else
 #endif // ^^^ _USE_STD_VECTOR_ALGORITHMS ^^^
                 {
@@ -6101,7 +6126,7 @@ _NODISCARD _CONSTEXPR20 _Iter_diff_t<_InIt> count(const _InIt _First, const _InI
                 }
 
                 return static_cast<_Iter_diff_t<_InIt>>(
-                    _STD __std_count_trivial(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val));
+                    _STD _Count_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Val));
             }
         }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -6305,16 +6330,7 @@ _CONSTEXPR20 void reverse(const _BidIt _First, const _BidIt _Last) { // reverse
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            if constexpr (_Nx == 1) {
-                ::__std_reverse_trivially_swappable_1(_STD _To_address(_UFirst), _STD _To_address(_ULast));
-            } else if constexpr (_Nx == 2) {
-                ::__std_reverse_trivially_swappable_2(_STD _To_address(_UFirst), _STD _To_address(_ULast));
-            } else if constexpr (_Nx == 4) {
-                ::__std_reverse_trivially_swappable_4(_STD _To_address(_UFirst), _STD _To_address(_ULast));
-            } else {
-                ::__std_reverse_trivially_swappable_8(_STD _To_address(_UFirst), _STD _To_address(_ULast));
-            }
-
+            _STD _Reverse_vectorized<_Nx>(_STD _To_address(_UFirst), _STD _To_address(_ULast));
             return;
         }
     }
@@ -6761,7 +6777,7 @@ constexpr _FwdIt _Max_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
     if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
         if (!_Is_constant_evaluated()) {
             const auto _First_ptr = _STD _To_address(_First);
-            const auto _Result    = _STD __std_max_element(_First_ptr, _STD _To_address(_Last));
+            const auto _Result    = _STD _Max_element_vectorized(_First_ptr, _STD _To_address(_Last));
             if constexpr (is_pointer_v<_FwdIt>) {
                 return _Result;
             } else {
@@ -6827,7 +6843,7 @@ namespace ranges {
             if (!_STD is_constant_evaluated()) {
                 const auto _First_ptr = _STD to_address(_First);
                 const auto _Last_ptr  = _First_ptr + (_Last - _First);
-                const auto _Result    = _STD __std_max_element(_First_ptr, _Last_ptr);
+                const auto _Result    = _STD _Max_element_vectorized(_First_ptr, _Last_ptr);
                 if constexpr (is_pointer_v<_It>) {
                     return _Result;
                 } else {
@@ -6887,7 +6903,7 @@ _NODISCARD constexpr _Ty(max)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
 #if _USE_STD_VECTOR_ALGORITHMS
     if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
         if (!_Is_constant_evaluated()) {
-            return static_cast<_Ty>(_STD __std_max(_Ilist.begin(), _Ilist.end()));
+            return static_cast<_Ty>(_STD _Max_vectorized(_Ilist.begin(), _Ilist.end()));
         }
     }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -6933,7 +6949,7 @@ namespace ranges {
 #if _USE_STD_VECTOR_ALGORITHMS
             if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<const _Ty*, _Pr>) {
                 if (!_STD is_constant_evaluated()) {
-                    return static_cast<_Ty>(_STD __std_max(_First, _Last));
+                    return static_cast<_Ty>(_STD _Max_vectorized(_First, _Last));
                 }
             }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -6955,7 +6971,7 @@ namespace ranges {
                 if (!_STD is_constant_evaluated()) {
                     const auto _First_ptr = _STD to_address(_UFirst);
                     const auto _Last_ptr  = _First_ptr + (_ULast - _UFirst);
-                    return static_cast<range_value_t<_Rng>>(_STD __std_max(_First_ptr, _Last_ptr));
+                    return static_cast<range_value_t<_Rng>>(_STD _Max_vectorized(_First_ptr, _Last_ptr));
                 }
             }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -6985,7 +7001,7 @@ constexpr _FwdIt _Min_element_unchecked(_FwdIt _First, _FwdIt _Last, _Pr _Pred)
     if constexpr (_Is_min_max_optimization_safe<_FwdIt, _Pr>) {
         if (!_Is_constant_evaluated()) {
             const auto _First_ptr = _STD _To_address(_First);
-            const auto _Result    = _STD __std_min_element(_First_ptr, _STD _To_address(_Last));
+            const auto _Result    = _STD _Min_element_vectorized(_First_ptr, _STD _To_address(_Last));
             if constexpr (is_pointer_v<_FwdIt>) {
                 return _Result;
             } else {
@@ -7051,7 +7067,7 @@ namespace ranges {
             if (!_STD is_constant_evaluated()) {
                 const auto _First_ptr = _STD to_address(_First);
                 const auto _Last_ptr  = _First_ptr + (_Last - _First);
-                const auto _Result    = _STD __std_min_element(_First_ptr, _Last_ptr);
+                const auto _Result    = _STD _Min_element_vectorized(_First_ptr, _Last_ptr);
                 if constexpr (is_pointer_v<_It>) {
                     return _Result;
                 } else {
@@ -7111,7 +7127,7 @@ _NODISCARD constexpr _Ty(min)(initializer_list<_Ty> _Ilist, _Pr _Pred) {
 #if _USE_STD_VECTOR_ALGORITHMS
     if constexpr (_Is_min_max_optimization_safe<const _Ty*, _Pr>) {
         if (!_Is_constant_evaluated()) {
-            return static_cast<_Ty>(_STD __std_min(_Ilist.begin(), _Ilist.end()));
+            return static_cast<_Ty>(_STD _Min_vectorized(_Ilist.begin(), _Ilist.end()));
         }
     }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -7151,7 +7167,7 @@ namespace ranges {
 #if _USE_STD_VECTOR_ALGORITHMS
             if constexpr (is_same_v<_Pj, identity> && _Is_min_max_optimization_safe<const _Ty*, _Pr>) {
                 if (!_STD is_constant_evaluated()) {
-                    return static_cast<_Ty>(_STD __std_min(_First, _Last));
+                    return static_cast<_Ty>(_STD _Min_vectorized(_First, _Last));
                 }
             }
 #endif // _USE_STD_VECTOR_ALGORITHMS
@@ -7173,7 +7189,7 @@ namespace ranges {
                 if (!_STD is_constant_evaluated()) {
                     const auto _First_ptr = _STD to_address(_UFirst);
                     const auto _Last_ptr  = _First_ptr + (_ULast - _UFirst);
-                    return static_cast<range_value_t<_Rng>>(_STD __std_min(_First_ptr, _Last_ptr));
+                    return static_cast<range_value_t<_Rng>>(_STD _Min_vectorized(_First_ptr, _Last_ptr));
                 }
             }
 #endif // _USE_STD_VECTOR_ALGORITHMS
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index 1c5fc74e809..321dd09ebeb 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -1163,12 +1163,12 @@ namespace {
 #endif // !_M_ARM64EC
     };
 
-    // _Minmax_element has exactly the same signature as the extern "C" functions
+    // __std_minmax_element_impl has exactly the same signature as the extern "C" functions
     // (__std_min_element_N, __std_max_element_N, __std_minmax_element_N), up to calling convention.
     // This makes sure the template specialization is fused with the extern "C" function.
     // In optimized builds it avoids an extra call, as this function is too large to inline.
     template <_Min_max_mode _Mode, class _Traits>
-    auto __stdcall _Minmax_element(const void* _First, const void* const _Last, const bool _Sign) noexcept {
+    auto __stdcall __std_minmax_element_impl(const void* _First, const void* const _Last, const bool _Sign) noexcept {
         _Min_max_element_t _Res = {_First, _First};
         auto _Cur_min_val       = _Traits::_Init_min_val;
         auto _Cur_max_val       = _Traits::_Init_max_val;
@@ -1386,12 +1386,12 @@ namespace {
         }
     }
 
-    // _Minmax has exactly the same signature as the extern "C" functions
+    // __std_minmax_impl has exactly the same signature as the extern "C" functions
     // (__std_min_Nn, __std_max_Nn, __std_minmax_Nn), up to calling convention.
     // This makes sure the template specialization is fused with the extern "C" function.
     // In optimized builds it avoids an extra call, as this function is too large to inline.
     template <_Min_max_mode _Mode, class _Traits, bool _Sign>
-    auto __stdcall _Minmax(const void* _First, const void* const _Last) noexcept {
+    auto __stdcall __std_minmax_impl(const void* _First, const void* const _Last) noexcept {
         using _Ty = std::conditional_t<_Sign, typename _Traits::_Signed_t, typename _Traits::_Unsigned_t>;
 
         _Ty _Cur_min_val; // initialized in both of the branches below
@@ -1529,212 +1529,214 @@ extern "C" {
 
 const void* __stdcall __std_min_element_1(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_min, _Minmax_traits_1>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_min, _Minmax_traits_1>(_First, _Last, _Signed);
 }
 
 const void* __stdcall __std_min_element_2(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_min, _Minmax_traits_2>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_min, _Minmax_traits_2>(_First, _Last, _Signed);
 }
 
 const void* __stdcall __std_min_element_4(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_min, _Minmax_traits_4>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_min, _Minmax_traits_4>(_First, _Last, _Signed);
 }
 
 const void* __stdcall __std_min_element_8(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_min, _Minmax_traits_8>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_min, _Minmax_traits_8>(_First, _Last, _Signed);
 }
 
-const void* __stdcall __std_min_element_f( // _Minmax_element's "signature" comment explains `bool _Unused`
+const void* __stdcall __std_min_element_f( // __std_minmax_element_impl's "signature" comment explains `bool _Unused`
     const void* const _First, const void* const _Last, const bool _Unused) noexcept {
-    return _Minmax_element<_Mode_min, _Minmax_traits_f>(_First, _Last, _Unused);
+    return __std_minmax_element_impl<_Mode_min, _Minmax_traits_f>(_First, _Last, _Unused);
 }
 
-const void* __stdcall __std_min_element_d( // _Minmax_element's "signature" comment explains `bool _Unused`
+const void* __stdcall __std_min_element_d( // __std_minmax_element_impl's "signature" comment explains `bool _Unused`
     const void* const _First, const void* const _Last, const bool _Unused) noexcept {
-    return _Minmax_element<_Mode_min, _Minmax_traits_d>(_First, _Last, _Unused);
+    return __std_minmax_element_impl<_Mode_min, _Minmax_traits_d>(_First, _Last, _Unused);
 }
 
 const void* __stdcall __std_max_element_1(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_max, _Minmax_traits_1>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_max, _Minmax_traits_1>(_First, _Last, _Signed);
 }
 
 const void* __stdcall __std_max_element_2(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_max, _Minmax_traits_2>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_max, _Minmax_traits_2>(_First, _Last, _Signed);
 }
 
 const void* __stdcall __std_max_element_4(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_max, _Minmax_traits_4>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_max, _Minmax_traits_4>(_First, _Last, _Signed);
 }
 
 const void* __stdcall __std_max_element_8(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_max, _Minmax_traits_8>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_max, _Minmax_traits_8>(_First, _Last, _Signed);
 }
 
-const void* __stdcall __std_max_element_f( // _Minmax_element's "signature" comment explains `bool _Unused`
+const void* __stdcall __std_max_element_f( // __std_minmax_element_impl's "signature" comment explains `bool _Unused`
     const void* const _First, const void* const _Last, const bool _Unused) noexcept {
-    return _Minmax_element<_Mode_max, _Minmax_traits_f>(_First, _Last, _Unused);
+    return __std_minmax_element_impl<_Mode_max, _Minmax_traits_f>(_First, _Last, _Unused);
 }
 
-const void* __stdcall __std_max_element_d( // _Minmax_element's "signature" comment explains `bool _Unused`
+const void* __stdcall __std_max_element_d( // __std_minmax_element_impl's "signature" comment explains `bool _Unused`
     const void* const _First, const void* const _Last, const bool _Unused) noexcept {
-    return _Minmax_element<_Mode_max, _Minmax_traits_d>(_First, _Last, _Unused);
+    return __std_minmax_element_impl<_Mode_max, _Minmax_traits_d>(_First, _Last, _Unused);
 }
 
 _Min_max_element_t __stdcall __std_minmax_element_1(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_both, _Minmax_traits_1>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_both, _Minmax_traits_1>(_First, _Last, _Signed);
 }
 
 _Min_max_element_t __stdcall __std_minmax_element_2(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_both, _Minmax_traits_2>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_both, _Minmax_traits_2>(_First, _Last, _Signed);
 }
 
 _Min_max_element_t __stdcall __std_minmax_element_4(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_both, _Minmax_traits_4>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_both, _Minmax_traits_4>(_First, _Last, _Signed);
 }
 
 _Min_max_element_t __stdcall __std_minmax_element_8(
     const void* const _First, const void* const _Last, const bool _Signed) noexcept {
-    return _Minmax_element<_Mode_both, _Minmax_traits_8>(_First, _Last, _Signed);
+    return __std_minmax_element_impl<_Mode_both, _Minmax_traits_8>(_First, _Last, _Signed);
 }
 
-_Min_max_element_t __stdcall __std_minmax_element_f( // _Minmax_element's "signature" comment explains `bool _Unused`
+// __std_minmax_element_impl's "signature" comment explains `bool _Unused`
+_Min_max_element_t __stdcall __std_minmax_element_f(
     const void* const _First, const void* const _Last, const bool _Unused) noexcept {
-    return _Minmax_element<_Mode_both, _Minmax_traits_f>(_First, _Last, _Unused);
+    return __std_minmax_element_impl<_Mode_both, _Minmax_traits_f>(_First, _Last, _Unused);
 }
 
-_Min_max_element_t __stdcall __std_minmax_element_d( // _Minmax_element's "signature" comment explains `bool _Unused`
+// __std_minmax_element_impl's "signature" comment explains `bool _Unused`
+_Min_max_element_t __stdcall __std_minmax_element_d(
     const void* const _First, const void* const _Last, const bool _Unused) noexcept {
-    return _Minmax_element<_Mode_both, _Minmax_traits_d>(_First, _Last, _Unused);
+    return __std_minmax_element_impl<_Mode_both, _Minmax_traits_d>(_First, _Last, _Unused);
 }
 
 __declspec(noalias) int8_t __stdcall __std_min_1i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_1, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_1, true>(_First, _Last);
 }
 
 __declspec(noalias) uint8_t __stdcall __std_min_1u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_1, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_1, false>(_First, _Last);
 }
 
 __declspec(noalias) int16_t __stdcall __std_min_2i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_2, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_2, true>(_First, _Last);
 }
 
 __declspec(noalias) uint16_t __stdcall __std_min_2u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_2, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_2, false>(_First, _Last);
 }
 
 __declspec(noalias) int32_t __stdcall __std_min_4i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_4, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_4, true>(_First, _Last);
 }
 
 __declspec(noalias) uint32_t __stdcall __std_min_4u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_4, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_4, false>(_First, _Last);
 }
 
 __declspec(noalias) int64_t __stdcall __std_min_8i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_8, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_8, true>(_First, _Last);
 }
 
 __declspec(noalias) uint64_t __stdcall __std_min_8u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_8, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_8, false>(_First, _Last);
 }
 
 __declspec(noalias) float __stdcall __std_min_f(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_f, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_f, true>(_First, _Last);
 }
 
 __declspec(noalias) double __stdcall __std_min_d(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_min, _Minmax_traits_d, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_min, _Minmax_traits_d, true>(_First, _Last);
 }
 
 __declspec(noalias) int8_t __stdcall __std_max_1i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_1, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_1, true>(_First, _Last);
 }
 
 __declspec(noalias) uint8_t __stdcall __std_max_1u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_1, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_1, false>(_First, _Last);
 }
 
 __declspec(noalias) int16_t __stdcall __std_max_2i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_2, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_2, true>(_First, _Last);
 }
 
 __declspec(noalias) uint16_t __stdcall __std_max_2u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_2, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_2, false>(_First, _Last);
 }
 
 __declspec(noalias) int32_t __stdcall __std_max_4i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_4, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_4, true>(_First, _Last);
 }
 
 __declspec(noalias) uint32_t __stdcall __std_max_4u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_4, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_4, false>(_First, _Last);
 }
 
 __declspec(noalias) int64_t __stdcall __std_max_8i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_8, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_8, true>(_First, _Last);
 }
 
 __declspec(noalias) uint64_t __stdcall __std_max_8u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_8, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_8, false>(_First, _Last);
 }
 
 __declspec(noalias) float __stdcall __std_max_f(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_f, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_f, true>(_First, _Last);
 }
 
 __declspec(noalias) double __stdcall __std_max_d(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_max, _Minmax_traits_d, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_max, _Minmax_traits_d, true>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_1i __stdcall __std_minmax_1i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_1, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_1, true>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_1u __stdcall __std_minmax_1u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_1, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_1, false>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_2i __stdcall __std_minmax_2i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_2, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_2, true>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_2u __stdcall __std_minmax_2u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_2, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_2, false>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_4i __stdcall __std_minmax_4i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_4, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_4, true>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_4u __stdcall __std_minmax_4u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_4, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_4, false>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_8i __stdcall __std_minmax_8i(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_8, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_8, true>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_8u __stdcall __std_minmax_8u(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_8, false>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_8, false>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_f __stdcall __std_minmax_f(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_f, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_f, true>(_First, _Last);
 }
 
 __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* const _First, const void* const _Last) noexcept {
-    return _Minmax<_Mode_both, _Minmax_traits_d, true>(_First, _Last);
+    return __std_minmax_impl<_Mode_both, _Minmax_traits_d, true>(_First, _Last);
 }
 
 } // extern "C"

From 29b30dfb3b671bef2b9e8890c7770ba00b7ca186 Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Tue, 9 Apr 2024 13:59:17 -0700
Subject: [PATCH 29/45] `<condition_variable>`: Avoid squirrelly forward
 declaration of `_Cnd_internal_imp_t` (#4545)

---
 stl/inc/__msvc_threads_core.hpp | 40 ++++++++++++---------------------
 stl/inc/condition_variable      |  6 ++---
 stl/inc/mutex                   |  6 ++---
 stl/src/cond.cpp                | 13 ++++++-----
 stl/src/primitives.hpp          | 17 ++++----------
 stl/src/sharedmutex.cpp         |  2 +-
 6 files changed, 32 insertions(+), 52 deletions(-)

diff --git a/stl/inc/__msvc_threads_core.hpp b/stl/inc/__msvc_threads_core.hpp
index 27cc751b442..94cc7346131 100644
--- a/stl/inc/__msvc_threads_core.hpp
+++ b/stl/inc/__msvc_threads_core.hpp
@@ -33,50 +33,38 @@ struct _Stl_critical_section {
 };
 
 struct _Mtx_internal_imp_t {
-#if defined(_CRT_WINDOWS) || defined(UNDOCKED_WINDOWS_UCRT)
-#ifdef _WIN64
-    static constexpr size_t _Critical_section_size = 16;
-#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
-    static constexpr size_t _Critical_section_size = 8;
-#endif // ^^^ !defined(_WIN64) ^^^
-#else // ^^^ Windows private STL / public STL vvv
-#ifdef _WIN64
+#if defined(_CRT_WINDOWS) || defined(UNDOCKED_WINDOWS_UCRT) // for Windows-internal code
+    static constexpr size_t _Critical_section_size = 2 * sizeof(void*);
+#elif defined(_WIN64) // ordinary 64-bit code
     static constexpr size_t _Critical_section_size = 64;
-#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
+#else // vvv ordinary 32-bit code vvv
     static constexpr size_t _Critical_section_size = 36;
-#endif // ^^^ !defined(_WIN64) ^^^
-#endif // ^^^ public STL ^^^
-
-    static constexpr size_t _Critical_section_align = alignof(void*);
+#endif // ^^^ ordinary 32-bit code ^^^
 
     int _Type{};
     union {
         _Stl_critical_section _Critical_section{};
-        _STD _Aligned_storage_t<_Critical_section_size, _Critical_section_align> _Cs_storage;
+        _STD _Aligned_storage_t<_Critical_section_size, alignof(void*)> _Cs_storage;
     };
     long _Thread_id{};
     int _Count{};
 };
 
-// Size and alignment for _Cnd_internal_imp_t
+using _Mtx_t = _Mtx_internal_imp_t*;
+
+struct _Cnd_internal_imp_t {
 #if defined(_CRT_WINDOWS) // for Windows-internal code
-_INLINE_VAR constexpr size_t _Cnd_internal_imp_size = 2 * sizeof(void*);
+    static constexpr size_t _Cnd_internal_imp_size = 2 * sizeof(void*);
 #elif defined(_WIN64) // ordinary 64-bit code
-_INLINE_VAR constexpr size_t _Cnd_internal_imp_size = 72;
+    static constexpr size_t _Cnd_internal_imp_size = 72;
 #else // vvv ordinary 32-bit code vvv
-_INLINE_VAR constexpr size_t _Cnd_internal_imp_size = 40;
+    static constexpr size_t _Cnd_internal_imp_size = 40;
 #endif // ^^^ ordinary 32-bit code ^^^
 
-_INLINE_VAR constexpr size_t _Cnd_internal_imp_alignment = alignof(void*);
-
-using _Mtx_t = _Mtx_internal_imp_t*;
+    _STD _Aligned_storage_t<_Cnd_internal_imp_size, alignof(void*)> _Cv_storage;
+};
 
-#ifdef _M_CEE // avoid warning LNK4248: unresolved typeref token for '_Cnd_internal_imp_t'; image may not run
-using _Cnd_t = void*;
-#else // ^^^ defined(_M_CEE) / !defined(_M_CEE) vvv
-struct _Cnd_internal_imp_t;
 using _Cnd_t = _Cnd_internal_imp_t*;
-#endif // ^^^ !defined(_M_CEE) ^^^
 } // extern "C"
 
 #pragma pop_macro("new")
diff --git a/stl/inc/condition_variable b/stl/inc/condition_variable
index 9878204252f..93f84507535 100644
--- a/stl/inc/condition_variable
+++ b/stl/inc/condition_variable
@@ -220,10 +220,10 @@ public:
 private:
     shared_ptr<mutex> _Myptr;
 
-    _Aligned_storage_t<_Cnd_internal_imp_size, _Cnd_internal_imp_alignment> _Cnd_storage;
+    _Cnd_internal_imp_t _Cnd_storage;
 
-    _NODISCARD _Cnd_t _Mycnd() noexcept { // get pointer to _Cnd_internal_imp_t inside _Cnd_storage
-        return reinterpret_cast<_Cnd_t>(&_Cnd_storage);
+    _NODISCARD _Cnd_t _Mycnd() noexcept {
+        return &_Cnd_storage;
     }
 
     template <class _Lock>
diff --git a/stl/inc/mutex b/stl/inc/mutex
index 42544d2204b..49291830219 100644
--- a/stl/inc/mutex
+++ b/stl/inc/mutex
@@ -637,10 +637,10 @@ public:
     }
 
 private:
-    _Aligned_storage_t<_Cnd_internal_imp_size, _Cnd_internal_imp_alignment> _Cnd_storage;
+    _Cnd_internal_imp_t _Cnd_storage;
 
-    _Cnd_t _Mycnd() noexcept { // get pointer to _Cnd_internal_imp_t inside _Cnd_storage
-        return reinterpret_cast<_Cnd_t>(&_Cnd_storage);
+    _Cnd_t _Mycnd() noexcept {
+        return &_Cnd_storage;
     }
 };
 
diff --git a/stl/src/cond.cpp b/stl/src/cond.cpp
index 38ae9c20a9c..4cb255335fa 100644
--- a/stl/src/cond.cpp
+++ b/stl/src/cond.cpp
@@ -14,7 +14,7 @@ extern "C" {
 
 
 _CRTIMP2_PURE void __cdecl _Cnd_init_in_situ(const _Cnd_t cond) noexcept { // initialize condition variable in situ
-    new (cond->_get_cv()) Concurrency::details::stl_condition_variable_win7;
+    new (Concurrency::details::_Get_cond_var(cond)) Concurrency::details::stl_condition_variable_win7;
 }
 
 _CRTIMP2_PURE void __cdecl _Cnd_destroy_in_situ(_Cnd_t) noexcept {} // destroy condition variable in situ
@@ -54,7 +54,7 @@ _CRTIMP2_PURE void __cdecl _Mtx_reset_owner(_Mtx_t mtx) noexcept { // set owner
 _CRTIMP2_PURE _Thrd_result __cdecl _Cnd_wait(const _Cnd_t cond, const _Mtx_t mtx) noexcept { // wait until signaled
     const auto cs = &mtx->_Critical_section;
     _Mtx_clear_owner(mtx);
-    cond->_get_cv()->wait(cs);
+    Concurrency::details::_Get_cond_var(cond)->wait(cs);
     _Mtx_reset_owner(mtx);
     return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
 }
@@ -66,13 +66,14 @@ _CRTIMP2_PURE _Thrd_result __cdecl _Cnd_timedwait(
     const auto cs    = &mtx->_Critical_section;
     if (target == nullptr) { // no target time specified, wait on mutex
         _Mtx_clear_owner(mtx);
-        cond->_get_cv()->wait(cs);
+        Concurrency::details::_Get_cond_var(cond)->wait(cs);
         _Mtx_reset_owner(mtx);
     } else { // target time specified, wait for it
         _timespec64 now;
         _Timespec64_get_sys(&now);
         _Mtx_clear_owner(mtx);
-        if (!cond->_get_cv()->wait_for(cs, _Xtime_diff_to_millis2(target, &now))) { // report timeout
+        if (!Concurrency::details::_Get_cond_var(cond)->wait_for(
+                cs, _Xtime_diff_to_millis2(target, &now))) { // report timeout
             _Timespec64_get_sys(&now);
             if (_Xtime_diff_to_millis2(target, &now) == 0) {
                 res = _Thrd_result::_Timedout;
@@ -84,12 +85,12 @@ _CRTIMP2_PURE _Thrd_result __cdecl _Cnd_timedwait(
 }
 
 _CRTIMP2_PURE _Thrd_result __cdecl _Cnd_signal(const _Cnd_t cond) noexcept { // release one waiting thread
-    cond->_get_cv()->notify_one();
+    Concurrency::details::_Get_cond_var(cond)->notify_one();
     return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
 }
 
 _CRTIMP2_PURE _Thrd_result __cdecl _Cnd_broadcast(const _Cnd_t cond) noexcept { // release all waiting threads
-    cond->_get_cv()->notify_all();
+    Concurrency::details::_Get_cond_var(cond)->notify_all();
     return _Thrd_result::_Success; // TRANSITION, ABI: Always succeeds
 }
 
diff --git a/stl/src/primitives.hpp b/stl/src/primitives.hpp
index cd888ab514e..ff9b5937256 100644
--- a/stl/src/primitives.hpp
+++ b/stl/src/primitives.hpp
@@ -3,6 +3,7 @@
 
 #pragma once
 
+#include <__msvc_threads_core.hpp>
 #include <cstdlib>
 #include <type_traits>
 
@@ -43,18 +44,8 @@ namespace Concurrency {
             CONDITION_VARIABLE m_condition_variable = CONDITION_VARIABLE_INIT;
         };
 
+        [[nodiscard]] inline stl_condition_variable_win7* _Get_cond_var(::_Cnd_internal_imp_t* _Cond) noexcept {
+            return reinterpret_cast<stl_condition_variable_win7*>(&_Cond->_Cv_storage);
+        }
     } // namespace details
 } // namespace Concurrency
-
-extern "C" {
-
-struct _Cnd_internal_imp_t {
-    std::_Aligned_storage_t<_Cnd_internal_imp_size, _Cnd_internal_imp_alignment> cv;
-
-    [[nodiscard]] Concurrency::details::stl_condition_variable_win7* _get_cv() noexcept {
-        // get pointer to implementation
-        return reinterpret_cast<Concurrency::details::stl_condition_variable_win7*>(&cv);
-    }
-};
-
-} // extern "C"
diff --git a/stl/src/sharedmutex.cpp b/stl/src/sharedmutex.cpp
index 73dbf6b2888..ef5e53f7450 100644
--- a/stl/src/sharedmutex.cpp
+++ b/stl/src/sharedmutex.cpp
@@ -50,7 +50,7 @@ _Thrd_result __stdcall _Cnd_timedwait_for(const _Cnd_t cond, const _Mtx_t mtx, c
     mtx->_Thread_id = -1;
     --mtx->_Count;
 
-    if (!cond->_get_cv()->wait_for(cs, target_ms)) { // report timeout
+    if (!Concurrency::details::_Get_cond_var(cond)->wait_for(cs, target_ms)) { // report timeout
         const auto end_ms = GetTickCount64();
         if (end_ms - start_ms >= target_ms) {
             res = _Thrd_result::_Timedout;

From daeb0a63b15191b34969b3522982adab344d9a49 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 05:05:30 +0800
Subject: [PATCH 30/45] Drop `inline`/`_INLINE_VAR` from templated `constexpr`
 variables in product and test codes (#4546)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/__msvc_bit_utils.hpp                  |   4 +-
 stl/inc/__msvc_chrono.hpp                     |  15 +-
 stl/inc/__msvc_filebuf.hpp                    |   2 +-
 stl/inc/__msvc_iter_core.hpp                  |   8 +-
 stl/inc/algorithm                             |  12 +-
 stl/inc/any                                   |  11 +-
 stl/inc/atomic                                |  13 +-
 stl/inc/chrono                                |  16 +-
 stl/inc/compare                               |   4 +-
 stl/inc/complex                               |   6 +-
 stl/inc/execution                             |   2 +-
 stl/inc/filesystem                            |  10 +-
 stl/inc/format                                |  18 +-
 stl/inc/functional                            |  16 +-
 stl/inc/mdspan                                |  10 +-
 stl/inc/numbers                               |  52 ++--
 stl/inc/numeric                               |   8 +-
 stl/inc/ranges                                | 176 ++++++-------
 stl/inc/ratio                                 |  16 +-
 stl/inc/regex                                 |   2 +-
 stl/inc/span                                  |   8 +-
 stl/inc/system_error                          |   4 +-
 stl/inc/tuple                                 |  43 ++--
 stl/inc/type_traits                           | 241 +++++++++---------
 stl/inc/utility                               |  24 +-
 stl/inc/variant                               |  38 +--
 stl/inc/vector                                |   4 +-
 stl/inc/xcharconv_ryu_tables.h                |   2 +-
 stl/inc/xhash                                 |   2 +-
 stl/inc/xlocale                               |   4 +-
 stl/inc/xmemory                               |  52 ++--
 stl/inc/xstring                               |   8 +-
 stl/inc/xtr1common                            |  17 +-
 stl/inc/xutility                              | 145 +++++------
 tests/std/include/is_permissive.hpp           |   2 +-
 tests/std/include/range_algorithm_support.hpp |   8 +-
 tests/std/include/test_mdspan_support.hpp     |   6 +-
 .../test.compile.pass.cpp                     |   4 +-
 .../floating_point_utils.hpp                  |  14 +-
 .../test.compile.pass.cpp                     |   6 +-
 tests/std/tests/P0088R3_variant/test.cpp      |   6 +-
 tests/std/tests/P0122R7_span/test.cpp         |   6 +-
 tests/std/tests/P0220R1_optional/test.cpp     |   2 +-
 tests/std/tests/P0448R4_spanstream/test.cpp   |   6 +-
 .../std/tests/P0768R1_spaceship_cpos/test.cpp |   2 +-
 .../test.cpp                                  |   2 +-
 .../tests/P0896R4_counted_iterator/test.cpp   |   4 +-
 .../test.compile.pass.cpp                     |   4 +-
 .../test.cpp                                  |   2 +-
 .../test.compile.pass.cpp                     |   8 +-
 .../tests/P0896R4_ranges_to_address/test.cpp  |   4 +-
 tests/std/tests/P0896R4_views_drop/test.cpp   |   4 +-
 tests/std/tests/P0896R4_views_take/test.cpp   |   4 +-
 tests/std/tests/P1614R2_spaceship/test.cpp    |   4 +-
 .../test.compile.pass.cpp                     |   3 +-
 55 files changed, 536 insertions(+), 558 deletions(-)

diff --git a/stl/inc/__msvc_bit_utils.hpp b/stl/inc/__msvc_bit_utils.hpp
index b5772b86cb0..2b910d69ab3 100644
--- a/stl/inc/__msvc_bit_utils.hpp
+++ b/stl/inc/__msvc_bit_utils.hpp
@@ -41,7 +41,7 @@ _INLINE_VAR constexpr int _Stl_isa_available_sse42 = 2; // equal to __ISA_AVAILA
 _INLINE_VAR constexpr int _Stl_isa_available_avx2  = 5; // equal to __ISA_AVAILABLE_AVX2
 
 template <class _UInt>
-_INLINE_VAR constexpr int _Unsigned_integer_digits = sizeof(_UInt) * CHAR_BIT;
+constexpr int _Unsigned_integer_digits = sizeof(_UInt) * CHAR_BIT;
 
 // Implementation of countl_zero without using specialized CPU instructions.
 // Used at compile time and when said instructions are not supported.
@@ -356,7 +356,7 @@ _NODISCARD inline int _Arm64_popcount(const unsigned long long _Val) noexcept {
 #endif // _HAS_NEON_INTRINSICS
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_standard_unsigned_integer =
+constexpr bool _Is_standard_unsigned_integer =
     _Is_any_of_v<remove_cv_t<_Ty>, unsigned char, unsigned short, unsigned int, unsigned long, unsigned long long>;
 
 template <class _Ty, enable_if_t<_Is_standard_unsigned_integer<_Ty>, int> = 0>
diff --git a/stl/inc/__msvc_chrono.hpp b/stl/inc/__msvc_chrono.hpp
index c29e3459ea1..f6857a61307 100644
--- a/stl/inc/__msvc_chrono.hpp
+++ b/stl/inc/__msvc_chrono.hpp
@@ -31,7 +31,7 @@ namespace chrono {
     struct treat_as_floating_point : is_floating_point<_Rep> {}; // tests for floating-point type
 
     _EXPORT_STD template <class _Rep>
-    _INLINE_VAR constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
+    constexpr bool treat_as_floating_point_v = treat_as_floating_point<_Rep>::value;
 
     _EXPORT_STD template <class _Rep>
     struct duration_values { // gets arithmetic properties of a type
@@ -53,10 +53,10 @@ namespace chrono {
 
 #if _HAS_CXX20
     template <class _Clock, class = void>
-    inline constexpr bool _Is_clock_v = false;
+    constexpr bool _Is_clock_v = false;
 
     template <class _Clock>
-    inline constexpr bool
+    constexpr bool
         _Is_clock_v<_Clock, void_t<typename _Clock::rep, typename _Clock::period, typename _Clock::duration,
                                 typename _Clock::time_point, decltype(_Clock::is_steady), decltype(_Clock::now())>> =
             true; // TRANSITION, GH-602
@@ -64,14 +64,14 @@ namespace chrono {
     _EXPORT_STD template <class _Clock>
     struct is_clock : bool_constant<_Is_clock_v<_Clock>> {};
     _EXPORT_STD template <class _Clock>
-    inline constexpr bool is_clock_v = _Is_clock_v<_Clock>;
+    constexpr bool is_clock_v = _Is_clock_v<_Clock>;
 #endif // _HAS_CXX20
 
     _EXPORT_STD template <class _Rep, class _Period = ratio<1>>
     class duration;
 
     template <class _Ty>
-    _INLINE_VAR constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;
+    constexpr bool _Is_duration_v = _Is_specialization_v<_Ty, duration>;
 
     _EXPORT_STD template <class _To, class _Rep, class _Period, enable_if_t<_Is_duration_v<_To>, int> = 0>
     constexpr _To duration_cast(const duration<_Rep, _Period>&) noexcept(
@@ -252,11 +252,10 @@ namespace chrono {
 } // namespace chrono
 
 template <class _Rep, class _Period>
-_INLINE_VAR constexpr bool _Is_trivially_swappable_v<chrono::duration<_Rep, _Period>> = _Is_trivially_swappable_v<_Rep>;
+constexpr bool _Is_trivially_swappable_v<chrono::duration<_Rep, _Period>> = _Is_trivially_swappable_v<_Rep>;
 
 template <class _Clock, class _Duration>
-_INLINE_VAR constexpr bool _Is_trivially_swappable_v<chrono::time_point<_Clock, _Duration>> =
-    _Is_trivially_swappable_v<_Duration>;
+constexpr bool _Is_trivially_swappable_v<chrono::time_point<_Clock, _Duration>> = _Is_trivially_swappable_v<_Duration>;
 
 _NODISCARD constexpr intmax_t _Lcm(const intmax_t _Ax, const intmax_t _Bx) noexcept {
     return (_Ax / _Gcd(_Ax, _Bx)) * _Bx;
diff --git a/stl/inc/__msvc_filebuf.hpp b/stl/inc/__msvc_filebuf.hpp
index 9f6738be1b8..4d8e76dbc17 100644
--- a/stl/inc/__msvc_filebuf.hpp
+++ b/stl/inc/__msvc_filebuf.hpp
@@ -51,7 +51,7 @@ namespace experimental {
 
 // clang-format off
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_any_path = _Is_any_of_v<_Ty
+constexpr bool _Is_any_path = _Is_any_of_v<_Ty
 #if _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
     , experimental::filesystem::path
 #endif // _FSTREAM_SUPPORTS_EXPERIMENTAL_FILESYSTEM
diff --git a/stl/inc/__msvc_iter_core.hpp b/stl/inc/__msvc_iter_core.hpp
index b3fce60040f..0595c87184f 100644
--- a/stl/inc/__msvc_iter_core.hpp
+++ b/stl/inc/__msvc_iter_core.hpp
@@ -34,7 +34,7 @@ _EXPORT_STD template <class _Ty, class _Alloc>
 struct uses_allocator : _Has_allocator_type<_Ty, _Alloc>::type {};
 
 _EXPORT_STD template <class _Ty, class _Alloc>
-_INLINE_VAR constexpr bool uses_allocator_v = uses_allocator<_Ty, _Alloc>::value;
+constexpr bool uses_allocator_v = uses_allocator<_Ty, _Alloc>::value;
 
 // from <iterator>
 _EXPORT_STD struct input_iterator_tag {};
@@ -386,7 +386,7 @@ struct iterator_traits<_Ty*> {
 };
 
 template <class _Ty>
-inline constexpr bool _Integer_class = requires {
+constexpr bool _Integer_class = requires {
     typename _Ty::_Signed_type;
     typename _Ty::_Unsigned_type;
 };
@@ -418,7 +418,7 @@ concept sentinel_for = semiregular<_Se>
 // clang-format on
 
 _EXPORT_STD template <class _Se, class _It>
-inline constexpr bool disable_sized_sentinel_for = false;
+constexpr bool disable_sized_sentinel_for = false;
 
 // clang-format off
 _EXPORT_STD template <class _Se, class _It>
@@ -454,7 +454,7 @@ namespace ranges {
 _EXPORT_STD using ranges::get;
 
 template <class _It, class _Se, ranges::subrange_kind _Ki>
-inline constexpr bool _Is_subrange_v<ranges::subrange<_It, _Se, _Ki>> = true;
+constexpr bool _Is_subrange_v<ranges::subrange<_It, _Se, _Ki>> = true;
 
 template <class _It, class _Se, ranges::subrange_kind _Ki>
 struct tuple_size<ranges::subrange<_It, _Se, _Ki>> : integral_constant<size_t, 2> {};
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 29672ceb0ff..e01f5629680 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -206,7 +206,7 @@ _INLINE_VAR constexpr ptrdiff_t _Threshold_find_first_of = 16;
 
 // Can we activate the vector algorithms for find_first_of?
 template <class _It1, class _It2, class _Pr>
-_INLINE_VAR constexpr bool _Vector_alg_in_find_first_of_is_safe =
+constexpr bool _Vector_alg_in_find_first_of_is_safe =
     _Equal_memcmp_is_safe<_It1, _It2, _Pr> // can replace value comparison with bitwise comparison
     && sizeof(_Iter_value_t<_It1>) <= 2; // pcmpestri compatible size
 _STD_END
@@ -223,7 +223,7 @@ _STD_BEGIN
 _INLINE_VAR constexpr int _ISORT_MAX = 32; // maximum size for insertion sort
 
 template <class _It>
-_INLINE_VAR constexpr _Iter_diff_t<_It> _Isort_max{_ISORT_MAX};
+constexpr _Iter_diff_t<_It> _Isort_max{_ISORT_MAX};
 
 template <class _Diff>
 constexpr ptrdiff_t _Temporary_buffer_size(const _Diff _Value) noexcept {
@@ -3537,11 +3537,11 @@ namespace ranges {
     _EXPORT_STD inline constexpr _Find_first_of_fn find_first_of;
 
     template <class _Ty>
-    inline constexpr bool _Is_trivially_ranges_swappable_v =
+    constexpr bool _Is_trivially_ranges_swappable_v =
         disjunction_v<conjunction<is_scalar<_Ty>, negation<is_enum<_Ty>>>, _Is_trivially_swappable<_Ty>>;
 
     template <class _Ty, size_t _Len>
-    inline constexpr bool _Is_trivially_ranges_swappable_v<_Ty[_Len]> = _Is_trivially_ranges_swappable_v<_Ty>;
+    constexpr bool _Is_trivially_ranges_swappable_v<_Ty[_Len]> = _Is_trivially_ranges_swappable_v<_Ty>;
 
     template <class _Ty>
     struct _Is_trivially_ranges_swappable : bool_constant<_Is_trivially_ranges_swappable_v<_Ty>> {};
@@ -3969,7 +3969,7 @@ namespace ranges {
 
 // TRANSITION, DevCom-10606350: help the compiler auto-vectorize for simple types
 template <class _UOutIt, class _InTy, class _NewTy, class _OutTy = remove_pointer_t<_UOutIt>>
-_INLINE_VAR constexpr bool _Can_vectorize_replace_copy = conjunction_v<is_pointer<_UOutIt>, is_same<_InTy, _NewTy>,
+constexpr bool _Can_vectorize_replace_copy = conjunction_v<is_pointer<_UOutIt>, is_same<_InTy, _NewTy>,
     disjunction<
 #ifdef __cpp_lib_byte
         conjunction<is_same<_InTy, byte>, is_same<_OutTy, byte>>,
@@ -4739,7 +4739,7 @@ template <class _InIt, class _OutIt>
 #if _HAS_CXX20
 concept
 #else
-_INLINE_VAR constexpr bool
+constexpr bool
 #endif
     _Can_reread_dest = _Is_cpp17_fwd_iter_v<_OutIt> && is_same_v<_Iter_value_t<_InIt>, _Iter_value_t<_OutIt>>;
 
diff --git a/stl/inc/any b/stl/inc/any
index 4986245dc3b..933a463e604 100644
--- a/stl/inc/any
+++ b/stl/inc/any
@@ -42,14 +42,14 @@ public:
 inline constexpr size_t _Any_trivial_space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);
 
 template <class _Ty>
-inline constexpr bool _Any_is_trivial =
+constexpr bool _Any_is_trivial =
     alignof(_Ty) <= alignof(max_align_t) && is_trivially_copyable_v<_Ty> && sizeof(_Ty) <= _Any_trivial_space_size;
 
 inline constexpr size_t _Any_small_space_size = (_Small_object_num_ptrs - 2) * sizeof(void*);
 
 template <class _Ty>
-inline constexpr bool _Any_is_small = alignof(_Ty) <= alignof(max_align_t)
-                                   && is_nothrow_move_constructible_v<_Ty> && sizeof(_Ty) <= _Any_small_space_size;
+constexpr bool _Any_is_small = alignof(_Ty) <= alignof(max_align_t)
+                            && is_nothrow_move_constructible_v<_Ty> && sizeof(_Ty) <= _Any_small_space_size;
 
 enum class _Any_representation : uintptr_t { _Trivial, _Big, _Small };
 
@@ -97,11 +97,10 @@ struct _Any_small_RTTI { // Hand-rolled vtable for nontrivial types that can be
 };
 
 template <class _Ty>
-inline constexpr _Any_big_RTTI _Any_big_RTTI_obj = {
-    &_Any_big_RTTI::_Destroy_impl<_Ty>, &_Any_big_RTTI::_Copy_impl<_Ty>};
+constexpr _Any_big_RTTI _Any_big_RTTI_obj = {&_Any_big_RTTI::_Destroy_impl<_Ty>, &_Any_big_RTTI::_Copy_impl<_Ty>};
 
 template <class _Ty>
-inline constexpr _Any_small_RTTI _Any_small_RTTI_obj = {
+constexpr _Any_small_RTTI _Any_small_RTTI_obj = {
     &_Any_small_RTTI::_Destroy_impl<_Ty>, &_Any_small_RTTI::_Copy_impl<_Ty>, &_Any_small_RTTI::_Move_impl<_Ty>};
 
 _EXPORT_STD class any { // storage for any (CopyConstructible) type
diff --git a/stl/inc/atomic b/stl/inc/atomic
index 18d1b3de576..5944c9e5aa8 100644
--- a/stl/inc/atomic
+++ b/stl/inc/atomic
@@ -330,8 +330,7 @@ struct _Storage_for {
 
 #if _CMPXCHG_MASK_OUT_PADDING_BITS
 template <class _Ty>
-inline constexpr bool _Might_have_non_value_bits =
-    !has_unique_object_representations_v<_Ty> && !is_floating_point_v<_Ty>;
+constexpr bool _Might_have_non_value_bits = !has_unique_object_representations_v<_Ty> && !is_floating_point_v<_Ty>;
 #endif // _CMPXCHG_MASK_OUT_PADDING_BITS
 
 _EXPORT_STD extern "C" inline void atomic_thread_fence(const memory_order _Order) noexcept {
@@ -1648,22 +1647,22 @@ struct _Atomic_integral<_Ty, 8> : _Atomic_storage<_Ty> { // atomic integral oper
 
 #if 1 // TRANSITION, ABI
 template <size_t _TypeSize>
-_INLINE_VAR constexpr bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
+constexpr bool _Is_always_lock_free = _TypeSize <= 8 && (_TypeSize & (_TypeSize - 1)) == 0;
 #else // ^^^ don't break ABI / break ABI vvv
 #if _ATOMIC_HAS_DCAS
 template <size_t _TypeSize>
-_INLINE_VAR constexpr bool _Is_always_lock_free = _TypeSize <= 2 * sizeof(void*);
+constexpr bool _Is_always_lock_free = _TypeSize <= 2 * sizeof(void*);
 #else // ^^^ _ATOMIC_HAS_DCAS / !_ATOMIC_HAS_DCAS vvv
 template <size_t _TypeSize>
-_INLINE_VAR constexpr bool _Is_always_lock_free = _TypeSize <= sizeof(void*);
+constexpr bool _Is_always_lock_free = _TypeSize <= sizeof(void*);
 #endif // ^^^ !_ATOMIC_HAS_DCAS ^^^
 #endif // ^^^ break ABI ^^^
 
 template <class _Ty, bool _Is_lock_free = _Is_always_lock_free<sizeof(_Ty)>>
-_INLINE_VAR constexpr bool _Deprecate_non_lock_free_volatile = true;
+constexpr bool _Deprecate_non_lock_free_volatile = true;
 
 template <class _Ty>
-_CXX20_DEPRECATE_VOLATILE _INLINE_VAR constexpr bool _Deprecate_non_lock_free_volatile<_Ty, false> = true;
+_CXX20_DEPRECATE_VOLATILE constexpr bool _Deprecate_non_lock_free_volatile<_Ty, false> = true;
 
 template <class _Ty>
 struct _Atomic_integral_facade : _Atomic_integral<_Ty> {
diff --git a/stl/inc/chrono b/stl/inc/chrono
index 0b55b90c39b..3a94bdeca66 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -1543,7 +1543,7 @@ namespace chrono {
     }
 
     template <class _To, class _From>
-    inline constexpr bool
+    constexpr bool
         _Duration_underflows_with = !treat_as_floating_point_v<typename _From::rep>
                                  && _From::period::den / _Gcd(_From::period::den, _To::period::den)
                                         > INTMAX_MAX / (_To::period::num / _Gcd(_From::period::num, _To::period::num));
@@ -2872,10 +2872,10 @@ namespace chrono {
     // [time.clock.cast.sys]
 
     template <class _TimePoint, class _Clock>
-    inline constexpr bool _Is_time_point_for_clock = false;
+    constexpr bool _Is_time_point_for_clock = false;
 
     template <class _Clock, class _Duration>
-    inline constexpr bool _Is_time_point_for_clock<time_point<_Clock, _Duration>, _Clock> = true;
+    constexpr bool _Is_time_point_for_clock<time_point<_Clock, _Duration>, _Clock> = true;
 
     template <class _SourceClock>
     struct clock_time_conversion<system_clock, _SourceClock> {
@@ -2947,17 +2947,17 @@ namespace chrono {
     };
 
     template <class _Conv1, class _Conv2, class _Tp, class = void>
-    inline constexpr bool _Has_two_step_conversion = false;
+    constexpr bool _Has_two_step_conversion = false;
 
     template <class _Conv1, class _Conv2, class _Tp>
-    inline constexpr bool
+    constexpr bool
         _Has_two_step_conversion<_Conv1, _Conv2, _Tp, void_t<decltype(_Conv1{}(_Conv2{}(_STD declval<_Tp>())))>> = true;
 
     template <class _Conv1, class _Conv2, class _Conv3, class _Tp, class = void>
-    inline constexpr bool _Has_three_step_conversion = false;
+    constexpr bool _Has_three_step_conversion = false;
 
     template <class _Conv1, class _Conv2, class _Conv3, class _Tp>
-    inline constexpr bool _Has_three_step_conversion<_Conv1, _Conv2, _Conv3, _Tp,
+    constexpr bool _Has_three_step_conversion<_Conv1, _Conv2, _Conv3, _Tp,
         void_t<decltype(_Conv1{}(_Conv2{}(_Conv3{}(_STD declval<_Tp>()))))>> = true;
 
     template <class _DestClock, class _SourceClock, class _Duration>
@@ -3004,7 +3004,7 @@ namespace chrono {
     }
 
     template <class _DestClock, class _SourceClock, class _Duration>
-    inline constexpr auto _Clock_cast_choice = _Choose_clock_cast<_DestClock, _SourceClock, _Duration>();
+    constexpr auto _Clock_cast_choice = _Choose_clock_cast<_DestClock, _SourceClock, _Duration>();
 
     _EXPORT_STD template <class _DestClock, class _SourceClock, class _Duration,
         enable_if_t<_Clock_cast_choice<_DestClock, _SourceClock, _Duration> != _Clock_cast_strategy::_None, int> = 0>
diff --git a/stl/inc/compare b/stl/inc/compare
index fb4a2aadb70..22f75090891 100644
--- a/stl/inc/compare
+++ b/stl/inc/compare
@@ -268,10 +268,10 @@ enum _Comparison_category : unsigned char {
 };
 
 template <class... _Types>
-inline constexpr unsigned char _Classify_category =
+constexpr unsigned char _Classify_category =
     _Comparison_category{(_Classify_category<_Types> | ... | _Comparison_category_strong)};
 template <class _Ty>
-inline constexpr unsigned char _Classify_category<_Ty> = _Comparison_category_none;
+constexpr unsigned char _Classify_category<_Ty> = _Comparison_category_none;
 template <>
 inline constexpr unsigned char _Classify_category<partial_ordering> = _Comparison_category_partial;
 template <>
diff --git a/stl/inc/complex b/stl/inc/complex
index dfae9d8f5ca..28c14468ca3 100644
--- a/stl/inc/complex
+++ b/stl/inc/complex
@@ -213,7 +213,7 @@ namespace _Math_algorithms {
         static constexpr float value{9.2233715e+18f};
     };
     template <class _Ty>
-    _INLINE_VAR constexpr _Ty _Hypot_leg_huge = _Hypot_leg_huge_helper<_Ty>::value;
+    constexpr _Ty _Hypot_leg_huge = _Hypot_leg_huge_helper<_Ty>::value;
 
     template <class _Ty>
     struct _Hypot_leg_tiny_helper {
@@ -224,7 +224,7 @@ namespace _Math_algorithms {
         static constexpr float value{4.440892e-16f};
     };
     template <class _Ty>
-    _INLINE_VAR constexpr _Ty _Hypot_leg_tiny = _Hypot_leg_tiny_helper<_Ty>::value;
+    constexpr _Ty _Hypot_leg_tiny = _Hypot_leg_tiny_helper<_Ty>::value;
 
     template <class _Ty>
     _NODISCARD _Ty _Norm_minus_one(const _Ty _Xval, const _Ty _Yval) noexcept {
@@ -912,7 +912,7 @@ public:
 };
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_unqual_fp = _Is_any_of_v<_Ty, float, double, long double>;
+constexpr bool _Is_unqual_fp = _Is_any_of_v<_Ty, float, double, long double>;
 
 template <class _Ty>
 struct _Complex_value {
diff --git a/stl/inc/execution b/stl/inc/execution
index b55ad69e937..28bd7011547 100644
--- a/stl/inc/execution
+++ b/stl/inc/execution
@@ -384,7 +384,7 @@ struct _Atomic_is_usually_lock_free : bool_constant<atomic<_Ty>::is_always_lock_
 };
 
 template <class _FwdIt>
-inline constexpr bool _Use_atomic_iterator = conjunction_v<bool_constant<_Is_ranges_random_iter_v<_FwdIt>>,
+constexpr bool _Use_atomic_iterator = conjunction_v<bool_constant<_Is_ranges_random_iter_v<_FwdIt>>,
     is_trivially_copyable<_FwdIt>, _Atomic_is_usually_lock_free<_FwdIt>>;
 
 template <class _Ty>
diff --git a/stl/inc/filesystem b/stl/inc/filesystem
index 2be38683047..c223967fc3e 100644
--- a/stl/inc/filesystem
+++ b/stl/inc/filesystem
@@ -162,14 +162,14 @@ namespace filesystem {
     }
 
     template <class _Ty, class = void>
-    inline constexpr bool _Is_Source_impl = false;
+    constexpr bool _Is_Source_impl = false;
 
     template <class _Ty>
-    inline constexpr bool _Is_Source_impl<_Ty, void_t<typename iterator_traits<_Ty>::value_type>> =
+    constexpr bool _Is_Source_impl<_Ty, void_t<typename iterator_traits<_Ty>::value_type>> =
         _Is_EcharT<typename iterator_traits<_Ty>::value_type>;
 
     template <class _Ty>
-    inline constexpr bool _Is_Source = _Is_Source_impl<decay_t<_Ty>>;
+    constexpr bool _Is_Source = _Is_Source_impl<decay_t<_Ty>>;
 
     _EXPORT_STD class path;
 
@@ -178,10 +178,10 @@ namespace filesystem {
                                                     // iterator_traits when determining if path is copyable.
 
     template <class _Elem, class _Traits, class _Alloc>
-    inline constexpr bool _Is_Source<basic_string<_Elem, _Traits, _Alloc>> = _Is_EcharT<_Elem>;
+    constexpr bool _Is_Source<basic_string<_Elem, _Traits, _Alloc>> = _Is_EcharT<_Elem>;
 
     template <class _Elem, class _Traits>
-    inline constexpr bool _Is_Source<basic_string_view<_Elem, _Traits>> = _Is_EcharT<_Elem>;
+    constexpr bool _Is_Source<basic_string_view<_Elem, _Traits>> = _Is_EcharT<_Elem>;
 
     struct _Normal_conversion {};
 
diff --git a/stl/inc/format b/stl/inc/format
index 9e5d6cdc05f..00c0aa1e2f4 100644
--- a/stl/inc/format
+++ b/stl/inc/format
@@ -667,13 +667,13 @@ concept _Formattable_with_non_const = semiregular<_Formatter>
                                       };
 
 template <class _Ty, class _CharT>
-inline constexpr bool _Is_basic_string_like_for = false;
+constexpr bool _Is_basic_string_like_for = false;
 
 template <class _CharT, class _Traits, class _Alloc>
-inline constexpr bool _Is_basic_string_like_for<basic_string<_CharT, _Traits, _Alloc>, _CharT> = true;
+constexpr bool _Is_basic_string_like_for<basic_string<_CharT, _Traits, _Alloc>, _CharT> = true;
 
 template <class _CharT, class _Traits>
-inline constexpr bool _Is_basic_string_like_for<basic_string_view<_CharT, _Traits>, _CharT> = true;
+constexpr bool _Is_basic_string_like_for<basic_string_view<_CharT, _Traits>, _CharT> = true;
 
 template <class _Context>
 struct _Format_arg_traits {
@@ -1612,7 +1612,7 @@ _NODISCARD constexpr basic_format_arg<_Context> _Get_arg(const _Context& _Ctx, c
 }
 
 template <class _Ty>
-inline constexpr bool _Is_signed_or_unsigned_large_integer_t =
+constexpr bool _Is_signed_or_unsigned_large_integer_t =
     _Is_any_of_v<remove_cv_t<_Ty>, int, unsigned int, long, unsigned long, long long, unsigned long long>;
 
 // Checks that the type and value of an argument associated with a dynamic
@@ -2464,20 +2464,20 @@ struct _Invalid_format_kind {
 };
 
 _EXPORT_STD template <class _Ty>
-inline constexpr _Invalid_format_kind<_Ty> format_kind;
+constexpr _Invalid_format_kind<_Ty> format_kind;
 
 template <class _Ty>
-inline constexpr bool _Is_two_tuple = false;
+constexpr bool _Is_two_tuple = false;
 
 template <class _Ty, class _Uty>
-inline constexpr bool _Is_two_tuple<pair<_Ty, _Uty>> = true;
+constexpr bool _Is_two_tuple<pair<_Ty, _Uty>> = true;
 
 template <class _Ty, class _Uty>
-inline constexpr bool _Is_two_tuple<tuple<_Ty, _Uty>> = true;
+constexpr bool _Is_two_tuple<tuple<_Ty, _Uty>> = true;
 
 template <_RANGES input_range _Rng>
     requires same_as<_Rng, remove_cvref_t<_Rng>>
-inline constexpr range_format format_kind<_Rng> = []() consteval {
+constexpr range_format format_kind<_Rng> = []() consteval {
     using _Ref_value_t = remove_cvref_t<_RANGES range_reference_t<_Rng>>;
     if constexpr (same_as<_Ref_value_t, _Rng>) {
         return range_format::disabled;
diff --git a/stl/inc/functional b/stl/inc/functional
index f34e81d36e6..a9b23ab6336 100644
--- a/stl/inc/functional
+++ b/stl/inc/functional
@@ -706,7 +706,7 @@ _EXPORT_STD template <class _Fty>
 class function;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Testable_callable_v =
+constexpr bool _Testable_callable_v =
     disjunction_v<is_pointer<_Ty>, _Is_specialization<_Ty, function>, is_member_pointer<_Ty>>;
 
 template <class _Ty>
@@ -745,8 +745,8 @@ private:
 _INLINE_VAR constexpr size_t _Space_size = (_Small_object_num_ptrs - 1) * sizeof(void*);
 
 template <class _Impl> // determine whether _Impl must be dynamically allocated
-_INLINE_VAR constexpr bool _Is_large = sizeof(_Impl) > _Space_size || alignof(_Impl) > alignof(max_align_t)
-                                    || !_Impl::_Nothrow_move::value;
+constexpr bool _Is_large = sizeof(_Impl) > _Space_size || alignof(_Impl) > alignof(max_align_t)
+                        || !_Impl::_Nothrow_move::value;
 
 #if _HAS_FUNCTION_ALLOCATOR_SUPPORT
 template <class _Callable, class _Alloc, class _Rx, class... _Types>
@@ -1391,7 +1391,7 @@ void __stdcall _Function_destroy_large(_Move_only_function_data& _Self) noexcept
 }
 
 template <class _Vt>
-inline constexpr size_t _Function_small_copy_size = // We copy Impl* and the functor data at once
+constexpr size_t _Function_small_copy_size = // We copy Impl* and the functor data at once
     _Move_only_function_data::_Buf_offset<_Vt> // Impl* plus possible alignment
     + (size_t{sizeof(_Vt) + sizeof(void*) - 1} & ~size_t{sizeof(void*) - 1}); // size in whole pointers
 
@@ -1972,7 +1972,7 @@ template <class _Tx>
 struct is_placeholder<const volatile _Tx> : is_placeholder<_Tx>::type {}; // ignore cv-qualifiers
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr int is_placeholder_v = is_placeholder<_Ty>::value;
+constexpr int is_placeholder_v = is_placeholder<_Ty>::value;
 
 template <class _Ret, class _Fx, class... _Types>
 class _Binder;
@@ -1993,7 +1993,7 @@ template <class _Tx>
 struct is_bind_expression<const volatile _Tx> : is_bind_expression<_Tx>::type {}; // ignore cv-qualifiers
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_bind_expression_v = is_bind_expression<_Ty>::value;
+constexpr bool is_bind_expression_v = is_bind_expression<_Ty>::value;
 
 template <class _Cv_TiD, bool = _Is_specialization_v<remove_cv_t<_Cv_TiD>, reference_wrapper>,
     bool = is_bind_expression_v<_Cv_TiD>, int = is_placeholder_v<_Cv_TiD>>
@@ -2102,10 +2102,10 @@ concept _Can_call_binder = requires(_CvFD& _Fx, _CvBoundTuple& _Bound_tuple, _Un
 };
 #else // ^^^ concept available / concept unavailable vvv
 template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple, class = void>
-_INLINE_VAR constexpr bool _Can_call_binder = false;
+constexpr bool _Can_call_binder = false;
 
 template <class _Ret, class _CvFD, class _IntSeq, class _CvBoundTuple, class _UnboundTuple>
-_INLINE_VAR constexpr bool _Can_call_binder<_Ret, _CvFD, _IntSeq, _CvBoundTuple, _UnboundTuple,
+constexpr bool _Can_call_binder<_Ret, _CvFD, _IntSeq, _CvBoundTuple, _UnboundTuple,
     void_t<decltype(_STD _Call_binder(_Invoker_ret<_Ret>{}, _IntSeq{}, _STD declval<_CvFD&>(),
         _STD declval<_CvBoundTuple&>(), _STD declval<_UnboundTuple>()))>> = true;
 #endif // ^^^ concept unavailable ^^^
diff --git a/stl/inc/mdspan b/stl/inc/mdspan
index 601c0b3874b..551f60b4931 100644
--- a/stl/inc/mdspan
+++ b/stl/inc/mdspan
@@ -37,7 +37,7 @@ template <class _IndexType>
 struct _Maybe_empty_array<_IndexType, 0> {};
 
 template <size_t... _Extents>
-inline constexpr size_t _Calculate_rank_dynamic = (static_cast<size_t>(_Extents == dynamic_extent) + ... + 0);
+constexpr size_t _Calculate_rank_dynamic = (static_cast<size_t>(_Extents == dynamic_extent) + ... + 0);
 
 struct _Extents_from_tuple {
     explicit _Extents_from_tuple() = default;
@@ -315,7 +315,7 @@ public:
 };
 
 template <class>
-inline constexpr size_t _Repeat_dynamic_extent = dynamic_extent;
+constexpr size_t _Repeat_dynamic_extent = dynamic_extent;
 
 template <class... _Integrals>
     requires (is_convertible_v<_Integrals, size_t> && ...)
@@ -333,10 +333,10 @@ _EXPORT_STD template <class _IndexType, size_t _Rank>
 using dextents = _Dextents_impl<_IndexType, make_index_sequence<_Rank>>::type;
 
 template <class _Ty>
-inline constexpr bool _Is_extents = false;
+constexpr bool _Is_extents = false;
 
 template <class _IndexType, size_t... _Args>
-inline constexpr bool _Is_extents<extents<_IndexType, _Args...>> = true;
+constexpr bool _Is_extents<extents<_IndexType, _Args...>> = true;
 
 template <class _Extents>
 class _Fwd_prod_of_extents {
@@ -425,7 +425,7 @@ public:
 };
 
 template <class _Layout, class _Mapping>
-inline constexpr bool _Is_mapping_of =
+constexpr bool _Is_mapping_of =
     is_same_v<typename _Layout::template mapping<typename _Mapping::extents_type>, _Mapping>;
 
 _EXPORT_STD struct layout_left {
diff --git a/stl/inc/numbers b/stl/inc/numbers
index db2ec33f794..e82ab5f8a70 100644
--- a/stl/inc/numbers
+++ b/stl/inc/numbers
@@ -28,58 +28,58 @@ namespace numbers {
     };
 
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty e_v = _Invalid<_Ty>{};
+    constexpr _Ty e_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty log2e_v = _Invalid<_Ty>{};
+    constexpr _Ty log2e_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty log10e_v = _Invalid<_Ty>{};
+    constexpr _Ty log10e_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty pi_v = _Invalid<_Ty>{};
+    constexpr _Ty pi_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty inv_pi_v = _Invalid<_Ty>{};
+    constexpr _Ty inv_pi_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty inv_sqrtpi_v = _Invalid<_Ty>{};
+    constexpr _Ty inv_sqrtpi_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty ln2_v = _Invalid<_Ty>{};
+    constexpr _Ty ln2_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty ln10_v = _Invalid<_Ty>{};
+    constexpr _Ty ln10_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty sqrt2_v = _Invalid<_Ty>{};
+    constexpr _Ty sqrt2_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty sqrt3_v = _Invalid<_Ty>{};
+    constexpr _Ty sqrt3_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty inv_sqrt3_v = _Invalid<_Ty>{};
+    constexpr _Ty inv_sqrt3_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty egamma_v = _Invalid<_Ty>{};
+    constexpr _Ty egamma_v = _Invalid<_Ty>{};
     _EXPORT_STD template <class _Ty>
-    inline constexpr _Ty phi_v = _Invalid<_Ty>{};
+    constexpr _Ty phi_v = _Invalid<_Ty>{};
 
     template <floating_point _Floating>
-    inline constexpr _Floating e_v<_Floating> = static_cast<_Floating>(2.718281828459045);
+    constexpr _Floating e_v<_Floating> = static_cast<_Floating>(2.718281828459045);
     template <floating_point _Floating>
-    inline constexpr _Floating log2e_v<_Floating> = static_cast<_Floating>(1.4426950408889634);
+    constexpr _Floating log2e_v<_Floating> = static_cast<_Floating>(1.4426950408889634);
     template <floating_point _Floating>
-    inline constexpr _Floating log10e_v<_Floating> = static_cast<_Floating>(0.4342944819032518);
+    constexpr _Floating log10e_v<_Floating> = static_cast<_Floating>(0.4342944819032518);
     template <floating_point _Floating>
-    inline constexpr _Floating pi_v<_Floating> = static_cast<_Floating>(3.141592653589793);
+    constexpr _Floating pi_v<_Floating> = static_cast<_Floating>(3.141592653589793);
     template <floating_point _Floating>
-    inline constexpr _Floating inv_pi_v<_Floating> = static_cast<_Floating>(0.3183098861837907);
+    constexpr _Floating inv_pi_v<_Floating> = static_cast<_Floating>(0.3183098861837907);
     template <floating_point _Floating>
-    inline constexpr _Floating inv_sqrtpi_v<_Floating> = static_cast<_Floating>(0.5641895835477563);
+    constexpr _Floating inv_sqrtpi_v<_Floating> = static_cast<_Floating>(0.5641895835477563);
     template <floating_point _Floating>
-    inline constexpr _Floating ln2_v<_Floating> = static_cast<_Floating>(0.6931471805599453);
+    constexpr _Floating ln2_v<_Floating> = static_cast<_Floating>(0.6931471805599453);
     template <floating_point _Floating>
-    inline constexpr _Floating ln10_v<_Floating> = static_cast<_Floating>(2.302585092994046);
+    constexpr _Floating ln10_v<_Floating> = static_cast<_Floating>(2.302585092994046);
     template <floating_point _Floating>
-    inline constexpr _Floating sqrt2_v<_Floating> = static_cast<_Floating>(1.4142135623730951);
+    constexpr _Floating sqrt2_v<_Floating> = static_cast<_Floating>(1.4142135623730951);
     template <floating_point _Floating>
-    inline constexpr _Floating sqrt3_v<_Floating> = static_cast<_Floating>(1.7320508075688772);
+    constexpr _Floating sqrt3_v<_Floating> = static_cast<_Floating>(1.7320508075688772);
     template <floating_point _Floating>
-    inline constexpr _Floating inv_sqrt3_v<_Floating> = static_cast<_Floating>(0.5773502691896257);
+    constexpr _Floating inv_sqrt3_v<_Floating> = static_cast<_Floating>(0.5773502691896257);
     template <floating_point _Floating>
-    inline constexpr _Floating egamma_v<_Floating> = static_cast<_Floating>(0.5772156649015329);
+    constexpr _Floating egamma_v<_Floating> = static_cast<_Floating>(0.5772156649015329);
     template <floating_point _Floating>
-    inline constexpr _Floating phi_v<_Floating> = static_cast<_Floating>(1.618033988749895);
+    constexpr _Floating phi_v<_Floating> = static_cast<_Floating>(1.618033988749895);
 
     _EXPORT_STD inline constexpr double e          = e_v<double>;
     _EXPORT_STD inline constexpr double log2e      = log2e_v<double>;
diff --git a/stl/inc/numeric b/stl/inc/numeric
index ffe819a36e3..6bad9695f31 100644
--- a/stl/inc/numeric
+++ b/stl/inc/numeric
@@ -49,7 +49,7 @@ _NODISCARD _CONSTEXPR20 _Ty accumulate(const _InIt _First, const _InIt _Last, _T
 #if _HAS_CXX17
 #if _STD_VECTORIZE_WITH_FLOAT_CONTROL
 template <class _InIt, class _Ty, class _BinOp>
-inline constexpr bool _Plus_on_arithmetic_ranges_reduction_v =
+constexpr bool _Plus_on_arithmetic_ranges_reduction_v =
     conjunction_v<is_arithmetic<_Ty>, is_arithmetic<remove_pointer_t<_InIt>>, is_same<plus<>, _BinOp>>;
 
 #pragma float_control(precise, off, push)
@@ -150,7 +150,7 @@ _NODISCARD _CONSTEXPR20 _Ty inner_product(const _InIt1 _First1, const _InIt1 _La
 #if _HAS_CXX17
 #if _STD_VECTORIZE_WITH_FLOAT_CONTROL
 template <class _InIt1, class _InIt2, class _Ty, class _BinOp1, class _BinOp2>
-inline constexpr bool _Default_ops_transform_reduce_v =
+constexpr bool _Default_ops_transform_reduce_v =
     conjunction_v<is_arithmetic<_Ty>, is_arithmetic<remove_pointer_t<_InIt1>>, is_arithmetic<remove_pointer_t<_InIt2>>,
         is_same<plus<>, _BinOp1>, is_same<multiplies<>, _BinOp2>>;
 
@@ -646,7 +646,7 @@ _NODISCARD constexpr common_type_t<_Mt, _Nt> lcm(const _Mt _Mx, const _Nt _Nx) n
 
 #if _HAS_CXX20
 template <class _Flt>
-inline constexpr _Flt _Floating_max{};
+constexpr _Flt _Floating_max{};
 template <>
 inline constexpr float _Floating_max<float> = FLT_MAX;
 template <>
@@ -655,7 +655,7 @@ template <>
 inline constexpr long double _Floating_max<long double> = LDBL_MAX;
 
 template <class _Flt>
-inline constexpr _Flt _Floating_min{};
+constexpr _Flt _Floating_min{};
 template <>
 inline constexpr float _Floating_min<float> = FLT_MIN;
 template <>
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 620930cc047..07e70c345d6 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -35,7 +35,7 @@ namespace ranges {
     // MUCH machinery defined in <xutility>
 
     template <class _Ty>
-    inline constexpr bool _Is_initializer_list = _Is_specialization_v<remove_cvref_t<_Ty>, initializer_list>;
+    constexpr bool _Is_initializer_list = _Is_specialization_v<remove_cvref_t<_Ty>, initializer_list>;
 
     template <auto> // _Require_constant<E> is a valid template-id iff E is a constant expression of structural type
     struct _Require_constant;
@@ -51,40 +51,39 @@ namespace ranges {
     using range_const_reference_t = iter_const_reference_t<iterator_t<_Rng>>;
 
     template <range _Ty>
-    inline constexpr auto _Compile_time_max_size =
-        (numeric_limits<_Make_unsigned_like_t<range_difference_t<_Ty>>>::max)();
+    constexpr auto _Compile_time_max_size = (numeric_limits<_Make_unsigned_like_t<range_difference_t<_Ty>>>::max)();
 
     template <sized_range _Ty>
-    inline constexpr auto _Compile_time_max_size<_Ty> = (numeric_limits<range_size_t<_Ty>>::max)();
+    constexpr auto _Compile_time_max_size<_Ty> = (numeric_limits<range_size_t<_Ty>>::max)();
 
 #ifdef __EDG__ // TRANSITION, VSO-1898880
     template <class _Ty>
     concept _Constant_sized_range = sized_range<_Ty> && requires { typename _Require_constant<_Ty::size()>; };
 
     template <_Constant_sized_range _Ty>
-    inline constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
+    constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
 #else // ^^^ workaround / no workaround vvv
     template <sized_range _Ty>
         requires requires { typename _Require_constant<_Ty::size()>; }
-    inline constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
+    constexpr auto _Compile_time_max_size<_Ty> = _Ty::size();
 #endif // ^^^ no workaround ^^^
 
     template <class _Ty, size_t _Size>
-    inline constexpr auto _Compile_time_max_size<_Ty[_Size]> = _Size;
+    constexpr auto _Compile_time_max_size<_Ty[_Size]> = _Size;
 
     template <class _Ty, size_t _Size>
-    inline constexpr auto _Compile_time_max_size<array<_Ty, _Size>> = _Size;
+    constexpr auto _Compile_time_max_size<array<_Ty, _Size>> = _Size;
 
     template <class _Ty, size_t _Size>
-    inline constexpr auto _Compile_time_max_size<const array<_Ty, _Size>> = _Size;
+    constexpr auto _Compile_time_max_size<const array<_Ty, _Size>> = _Size;
 
     template <class _Ty, size_t _Extent>
         requires (_Extent != dynamic_extent)
-    inline constexpr auto _Compile_time_max_size<span<_Ty, _Extent>> = _Extent;
+    constexpr auto _Compile_time_max_size<span<_Ty, _Extent>> = _Extent;
 
     template <class _Ty, size_t _Extent>
         requires (_Extent != dynamic_extent)
-    inline constexpr auto _Compile_time_max_size<const span<_Ty, _Extent>> = _Extent;
+    constexpr auto _Compile_time_max_size<const span<_Ty, _Extent>> = _Extent;
 #endif // _HAS_CXX23
 
     // clang-format off
@@ -991,11 +990,11 @@ namespace ranges {
     };
 
     template <class _Ty>
-    inline constexpr bool enable_borrowed_range<empty_view<_Ty>> = true;
+    constexpr bool enable_borrowed_range<empty_view<_Ty>> = true;
 
     namespace views {
         _EXPORT_STD template <class _Ty>
-        inline constexpr empty_view<_Ty> empty;
+        constexpr empty_view<_Ty> empty;
     } // namespace views
 
     _EXPORT_STD template <_Valid_movable_box_object _Ty>
@@ -1444,7 +1443,7 @@ namespace ranges {
     // clang-format on
 
     template <class _Wi, class _Bo>
-    inline constexpr bool enable_borrowed_range<iota_view<_Wi, _Bo>> = true;
+    constexpr bool enable_borrowed_range<iota_view<_Wi, _Bo>> = true;
 
     namespace views {
         struct _Iota_fn {
@@ -1825,7 +1824,7 @@ namespace ranges {
         };
 
         _EXPORT_STD template <class _Ty>
-        inline constexpr _Istream_fn<_Ty> istream;
+        constexpr _Istream_fn<_Ty> istream;
     } // namespace views
 
     _EXPORT_STD template <range _Rng>
@@ -1883,14 +1882,14 @@ namespace ranges {
     ref_view(_Rng&) -> ref_view<_Rng>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<ref_view<_Rng>> = true;
+    constexpr bool enable_borrowed_range<ref_view<_Rng>> = true;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<const ref_view<_Rng>> = _Compile_time_max_size<_Rng>;
 #endif // _HAS_CXX23
 
     _EXPORT_STD template <range _Rng>
@@ -1978,14 +1977,14 @@ namespace ranges {
     };
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<owning_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<owning_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<owning_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<owning_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const owning_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const owning_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -2122,14 +2121,14 @@ namespace ranges {
     as_rvalue_view(_Rng&&) -> as_rvalue_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<as_rvalue_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<as_rvalue_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<as_rvalue_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<as_rvalue_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const as_rvalue_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const as_rvalue_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -2411,7 +2410,7 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Pr>
-    inline constexpr auto _Compile_time_max_size<filter_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<filter_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -2837,10 +2836,10 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Fn>
-    inline constexpr auto _Compile_time_max_size<transform_view<_Rng, _Fn>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<transform_view<_Rng, _Fn>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng, class _Fn>
-    inline constexpr auto _Compile_time_max_size<const transform_view<_Rng, _Fn>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const transform_view<_Rng, _Fn>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -3048,14 +3047,14 @@ namespace ranges {
     take_view(_Rng&&, range_difference_t<_Rng>) -> take_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<take_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<take_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<take_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<take_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const take_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const take_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -3297,10 +3296,10 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Pr>
-    inline constexpr auto _Compile_time_max_size<take_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<take_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng, class _Pr>
-    inline constexpr auto _Compile_time_max_size<const take_while_view<_Rng, _Pr>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const take_while_view<_Rng, _Pr>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -3448,14 +3447,14 @@ namespace ranges {
     drop_view(_Rng&&, range_difference_t<_Rng>) -> drop_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<drop_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<drop_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<drop_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<drop_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const drop_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const drop_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -3621,11 +3620,11 @@ namespace ranges {
     drop_while_view(_Rng&&, _Pr) -> drop_while_view<views::all_t<_Rng>, _Pr>;
 
     template <class _Rng, class _Pr>
-    inline constexpr bool enable_borrowed_range<drop_while_view<_Rng, _Pr>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<drop_while_view<_Rng, _Pr>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng, class _Pr>
-    inline constexpr auto _Compile_time_max_size<drop_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<drop_while_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -4052,11 +4051,10 @@ namespace ranges {
     }
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<join_view<_Rng>> = _Join_view_compile_time_max_size<_Rng>();
+    constexpr auto _Compile_time_max_size<join_view<_Rng>> = _Join_view_compile_time_max_size<_Rng>();
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const join_view<_Rng>> =
-        _Join_view_compile_time_max_size<const _Rng>();
+    constexpr auto _Compile_time_max_size<const join_view<_Rng>> = _Join_view_compile_time_max_size<const _Rng>();
 #endif // _HAS_CXX23
 
     namespace views {
@@ -4585,11 +4583,11 @@ namespace ranges {
     }
 
     template <class _Rng, class _Pat>
-    inline constexpr auto _Compile_time_max_size<join_with_view<_Rng, _Pat>> =
+    constexpr auto _Compile_time_max_size<join_with_view<_Rng, _Pat>> =
         _Join_with_view_compile_time_max_size<_Rng, _Pat>();
 
     template <class _Rng, class _Pat>
-    inline constexpr auto _Compile_time_max_size<const join_with_view<_Rng, _Pat>> =
+    constexpr auto _Compile_time_max_size<const join_with_view<_Rng, _Pat>> =
         _Join_with_view_compile_time_max_size<const _Rng, const _Pat>();
 #endif // _HAS_CXX23
 
@@ -5005,11 +5003,10 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Pat>
-    inline constexpr auto _Compile_time_max_size<lazy_split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<lazy_split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng, class _Pat>
-    inline constexpr auto _Compile_time_max_size<const lazy_split_view<_Rng, _Pat>> =
-        _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const lazy_split_view<_Rng, _Pat>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -5195,7 +5192,7 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Pat>
-    inline constexpr auto _Compile_time_max_size<split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<split_view<_Rng, _Pat>> = _Compile_time_max_size<_Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -5347,14 +5344,14 @@ namespace ranges {
     common_view(_Rng&&) -> common_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<common_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<common_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<common_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<common_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const common_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const common_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -5475,14 +5472,14 @@ namespace ranges {
     reverse_view(_Rng&&) -> reverse_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<reverse_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<reverse_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<reverse_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<reverse_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const reverse_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const reverse_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -5621,14 +5618,14 @@ namespace ranges {
     as_const_view(_Rng&&) -> as_const_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<as_const_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<as_const_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<as_const_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<as_const_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const as_const_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const as_const_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -6088,15 +6085,14 @@ namespace ranges {
     };
 
     template <class _Rng, size_t _Index>
-    inline constexpr bool enable_borrowed_range<elements_view<_Rng, _Index>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<elements_view<_Rng, _Index>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng, size_t _Index>
-    inline constexpr auto _Compile_time_max_size<elements_view<_Rng, _Index>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<elements_view<_Rng, _Index>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng, size_t _Index>
-    inline constexpr auto _Compile_time_max_size<const elements_view<_Rng, _Index>> =
-        _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const elements_view<_Rng, _Index>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     _EXPORT_STD template <class _Rng>
@@ -6118,7 +6114,7 @@ namespace ranges {
         };
 
         _EXPORT_STD template <size_t _Index>
-        inline constexpr _Elements_fn<_Index> elements;
+        constexpr _Elements_fn<_Index> elements;
         _EXPORT_STD inline constexpr auto keys   = elements<0>;
         _EXPORT_STD inline constexpr auto values = elements<1>;
     } // namespace views
@@ -6439,14 +6435,14 @@ namespace ranges {
     enumerate_view(_Rng&&) -> enumerate_view<views::all_t<_Rng>>;
 
     template <class _Rng>
-    inline constexpr bool enable_borrowed_range<enumerate_view<_Rng>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<enumerate_view<_Rng>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<enumerate_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<enumerate_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const enumerate_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const enumerate_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -7038,15 +7034,15 @@ namespace ranges {
     chunk_view(_Rng&&, range_difference_t<_Rng>) -> chunk_view<views::all_t<_Rng>>;
 
     template <class _Vw>
-    inline constexpr bool enable_borrowed_range<chunk_view<_Vw>> = enable_borrowed_range<_Vw> && forward_range<_Vw>;
+    constexpr bool enable_borrowed_range<chunk_view<_Vw>> = enable_borrowed_range<_Vw> && forward_range<_Vw>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<chunk_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<chunk_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
         requires forward_range<_Rng>
-    inline constexpr auto _Compile_time_max_size<const chunk_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const chunk_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -7438,14 +7434,14 @@ namespace ranges {
     slide_view(_Rng&&, range_difference_t<_Rng>) -> slide_view<views::all_t<_Rng>>;
 
     template <class _Vw>
-    inline constexpr bool enable_borrowed_range<slide_view<_Vw>> = enable_borrowed_range<_Vw>;
+    constexpr bool enable_borrowed_range<slide_view<_Vw>> = enable_borrowed_range<_Vw>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<slide_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<slide_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const slide_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const slide_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -7648,7 +7644,7 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Pr>
-    inline constexpr auto _Compile_time_max_size<chunk_by_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<chunk_by_view<_Rng, _Pr>> = _Compile_time_max_size<_Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -8036,14 +8032,14 @@ namespace ranges {
     stride_view(_Rng&&, range_difference_t<_Rng>) -> stride_view<views::all_t<_Rng>>;
 
     template <class _Vw>
-    inline constexpr bool enable_borrowed_range<stride_view<_Vw>> = enable_borrowed_range<_Vw>;
+    constexpr bool enable_borrowed_range<stride_view<_Vw>> = enable_borrowed_range<_Vw>;
 
 #if _HAS_CXX23
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<stride_view<_Rng>> = _Compile_time_max_size<_Rng>;
+    constexpr auto _Compile_time_max_size<stride_view<_Rng>> = _Compile_time_max_size<_Rng>;
 
     template <class _Rng>
-    inline constexpr auto _Compile_time_max_size<const stride_view<_Rng>> = _Compile_time_max_size<const _Rng>;
+    constexpr auto _Compile_time_max_size<const stride_view<_Rng>> = _Compile_time_max_size<const _Rng>;
 #endif // _HAS_CXX23
 
     namespace views {
@@ -8542,7 +8538,7 @@ namespace ranges {
     zip_view(_RangeTypes&&...) -> zip_view<views::all_t<_RangeTypes>...>;
 
     template <class... _ViewTypes>
-    inline constexpr bool enable_borrowed_range<zip_view<_ViewTypes...>> = (enable_borrowed_range<_ViewTypes> && ...);
+    constexpr bool enable_borrowed_range<zip_view<_ViewTypes...>> = (enable_borrowed_range<_ViewTypes> && ...);
 
 #if _HAS_CXX23
     template <class... _Rngs>
@@ -8552,11 +8548,10 @@ namespace ranges {
     }
 
     template <class... _Rngs>
-    inline constexpr auto _Compile_time_max_size<zip_view<_Rngs...>> = _Zip_view_compile_time_max_size<_Rngs...>();
+    constexpr auto _Compile_time_max_size<zip_view<_Rngs...>> = _Zip_view_compile_time_max_size<_Rngs...>();
 
     template <class... _Rngs>
-    inline constexpr auto _Compile_time_max_size<const zip_view<_Rngs...>> =
-        _Zip_view_compile_time_max_size<const _Rngs...>();
+    constexpr auto _Compile_time_max_size<const zip_view<_Rngs...>> = _Zip_view_compile_time_max_size<const _Rngs...>();
 #endif // _HAS_CXX23
 
     namespace views {
@@ -8899,11 +8894,11 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Fn, class... _Rngs>
-    inline constexpr auto _Compile_time_max_size<zip_transform_view<_Fn, _Rngs...>> =
+    constexpr auto _Compile_time_max_size<zip_transform_view<_Fn, _Rngs...>> =
         _Compile_time_max_size<zip_view<_Rngs...>>;
 
     template <class _Fn, class... _Rngs>
-    inline constexpr auto _Compile_time_max_size<const zip_transform_view<_Fn, _Rngs...>> =
+    constexpr auto _Compile_time_max_size<const zip_transform_view<_Fn, _Rngs...>> =
         _Compile_time_max_size<const zip_view<_Rngs...>>;
 #endif // _HAS_CXX23
 
@@ -8970,10 +8965,10 @@ namespace ranges {
     using _Repeated_tuple = _Repeated_tuple_impl<_Ty, make_index_sequence<_Nx>>::type;
 
     template <class _Fn, class _Ty, class _Indices>
-    inline constexpr bool _Regular_invocable_with_repeated_type_impl = false;
+    constexpr bool _Regular_invocable_with_repeated_type_impl = false;
 
     template <class _Fn, class _Ty, size_t... _Indices>
-    inline constexpr bool _Regular_invocable_with_repeated_type_impl<_Fn, _Ty, index_sequence<_Indices...>> =
+    constexpr bool _Regular_invocable_with_repeated_type_impl<_Fn, _Ty, index_sequence<_Indices...>> =
         regular_invocable<_Fn, _Repeat_type<_Ty, _Indices>...>;
 
     template <class _Fn, class _Ty, size_t _Nx>
@@ -9373,7 +9368,7 @@ namespace ranges {
     };
 
     template <class _Rng, size_t _Nx>
-    inline constexpr bool enable_borrowed_range<adjacent_view<_Rng, _Nx>> = enable_borrowed_range<_Rng>;
+    constexpr bool enable_borrowed_range<adjacent_view<_Rng, _Nx>> = enable_borrowed_range<_Rng>;
 
 #if _HAS_CXX23
     template <class _Rng, size_t _Nx>
@@ -9385,11 +9380,10 @@ namespace ranges {
     }
 
     template <class _Rng, size_t _Nx>
-    inline constexpr auto _Compile_time_max_size<adjacent_view<_Rng, _Nx>> =
-        _Adjacent_view_compile_time_max_size<_Rng, _Nx>();
+    constexpr auto _Compile_time_max_size<adjacent_view<_Rng, _Nx>> = _Adjacent_view_compile_time_max_size<_Rng, _Nx>();
 
     template <class _Rng, size_t _Nx>
-    inline constexpr auto _Compile_time_max_size<const adjacent_view<_Rng, _Nx>> =
+    constexpr auto _Compile_time_max_size<const adjacent_view<_Rng, _Nx>> =
         _Adjacent_view_compile_time_max_size<const _Rng, _Nx>();
 #endif // _HAS_CXX23
 
@@ -9414,7 +9408,7 @@ namespace ranges {
         };
 
         _EXPORT_STD template <size_t _Nx>
-        inline constexpr _Adjacent_fn<_Nx> adjacent;
+        constexpr _Adjacent_fn<_Nx> adjacent;
         _EXPORT_STD inline constexpr _Adjacent_fn<2> pairwise;
     } // namespace views
 
@@ -9730,11 +9724,11 @@ namespace ranges {
 
 #if _HAS_CXX23
     template <class _Rng, class _Fn, size_t _Nx>
-    inline constexpr auto _Compile_time_max_size<adjacent_transform_view<_Rng, _Fn, _Nx>> =
+    constexpr auto _Compile_time_max_size<adjacent_transform_view<_Rng, _Fn, _Nx>> =
         _Compile_time_max_size<adjacent_view<_Rng, _Nx>>;
 
     template <class _Rng, class _Fn, size_t _Nx>
-    inline constexpr auto _Compile_time_max_size<const adjacent_transform_view<_Rng, _Fn, _Nx>> =
+    constexpr auto _Compile_time_max_size<const adjacent_transform_view<_Rng, _Fn, _Nx>> =
         _Compile_time_max_size<const adjacent_view<_Rng, _Nx>>;
 #endif // _HAS_CXX23
 
@@ -9772,7 +9766,7 @@ namespace ranges {
         };
 
         _EXPORT_STD template <size_t _Nx>
-        inline constexpr _Adjacent_transform_fn<_Nx> adjacent_transform;
+        constexpr _Adjacent_transform_fn<_Nx> adjacent_transform;
         _EXPORT_STD inline constexpr _Adjacent_transform_fn<2> pairwise_transform;
     } // namespace views
 
@@ -10273,11 +10267,11 @@ namespace ranges {
     }
 
     template <class... _Rngs>
-    inline constexpr auto _Compile_time_max_size<cartesian_product_view<_Rngs...>> =
+    constexpr auto _Compile_time_max_size<cartesian_product_view<_Rngs...>> =
         _Cartesian_product_view_compile_time_max_size<_Rngs...>();
 
     template <class... _Rngs>
-    inline constexpr auto _Compile_time_max_size<const cartesian_product_view<_Rngs...>> =
+    constexpr auto _Compile_time_max_size<const cartesian_product_view<_Rngs...>> =
         _Cartesian_product_view_compile_time_max_size<const _Rngs...>();
 #endif // _HAS_CXX23
 
diff --git a/stl/inc/ratio b/stl/inc/ratio
index 429a2b9f3ec..ea8ecdf7495 100644
--- a/stl/inc/ratio
+++ b/stl/inc/ratio
@@ -76,10 +76,10 @@ struct ratio { // holds the ratio of _Nx to _Dx
 };
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_ratio_v = false; // test for ratio type
+constexpr bool _Is_ratio_v = false; // test for ratio type
 
 template <intmax_t _Rx1, intmax_t _Rx2>
-_INLINE_VAR constexpr bool _Is_ratio_v<ratio<_Rx1, _Rx2>> = true;
+constexpr bool _Is_ratio_v<ratio<_Rx1, _Rx2>> = true;
 
 template <class _Rx1, class _Rx2>
 struct _Ratio_add { // add two ratios
@@ -167,7 +167,7 @@ struct ratio_equal : bool_constant<_Rx1::num == _Rx2::num && _Rx1::den == _Rx2::
 };
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
-_INLINE_VAR constexpr bool ratio_equal_v = ratio_equal<_Rx1, _Rx2>::value;
+constexpr bool ratio_equal_v = ratio_equal<_Rx1, _Rx2>::value;
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_not_equal : bool_constant<!ratio_equal_v<_Rx1, _Rx2>> { // tests if ratio != ratio
@@ -175,7 +175,7 @@ struct ratio_not_equal : bool_constant<!ratio_equal_v<_Rx1, _Rx2>> { // tests if
 };
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
-_INLINE_VAR constexpr bool ratio_not_equal_v = ratio_not_equal<_Rx1, _Rx2>::value;
+constexpr bool ratio_not_equal_v = ratio_not_equal<_Rx1, _Rx2>::value;
 
 struct _Big_uint128 {
     uint64_t _Upper;
@@ -231,7 +231,7 @@ struct ratio_less : bool_constant<_Ratio_less(_Rx1::num, _Rx1::den, _Rx2::num, _
 };
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
-_INLINE_VAR constexpr bool ratio_less_v = ratio_less<_Rx1, _Rx2>::value;
+constexpr bool ratio_less_v = ratio_less<_Rx1, _Rx2>::value;
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_less_equal : bool_constant<!ratio_less_v<_Rx2, _Rx1>> { // tests if ratio <= ratio
@@ -240,7 +240,7 @@ struct ratio_less_equal : bool_constant<!ratio_less_v<_Rx2, _Rx1>> { // tests if
 };
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
-_INLINE_VAR constexpr bool ratio_less_equal_v = ratio_less_equal<_Rx1, _Rx2>::value;
+constexpr bool ratio_less_equal_v = ratio_less_equal<_Rx1, _Rx2>::value;
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_greater : ratio_less<_Rx2, _Rx1>::type { // tests if ratio > ratio
@@ -248,7 +248,7 @@ struct ratio_greater : ratio_less<_Rx2, _Rx1>::type { // tests if ratio > ratio
 };
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
-_INLINE_VAR constexpr bool ratio_greater_v = ratio_greater<_Rx1, _Rx2>::value;
+constexpr bool ratio_greater_v = ratio_greater<_Rx1, _Rx2>::value;
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
 struct ratio_greater_equal : bool_constant<!ratio_less_v<_Rx1, _Rx2>> { // tests if ratio >= ratio
@@ -257,7 +257,7 @@ struct ratio_greater_equal : bool_constant<!ratio_less_v<_Rx1, _Rx2>> { // tests
 };
 
 _EXPORT_STD template <class _Rx1, class _Rx2>
-_INLINE_VAR constexpr bool ratio_greater_equal_v = ratio_greater_equal<_Rx1, _Rx2>::value;
+constexpr bool ratio_greater_equal_v = ratio_greater_equal<_Rx1, _Rx2>::value;
 
 _EXPORT_STD using atto  = ratio<1, 1000000000000000000LL>;
 _EXPORT_STD using femto = ratio<1, 1000000000000000LL>;
diff --git a/stl/inc/regex b/stl/inc/regex
index b9956592e0e..426b4a9946a 100644
--- a/stl/inc/regex
+++ b/stl/inc/regex
@@ -196,7 +196,7 @@ struct _Char_traits_lt {
 // library-provided char_traits::eq behaves like equal_to<_Elem>
 // TRANSITION: This should not be activated for user-defined specializations of char_traits
 template <class _Elem>
-_INLINE_VAR constexpr bool _Can_memcmp_elements_with_pred<_Elem, _Elem, _Char_traits_eq<char_traits<_Elem>>> =
+constexpr bool _Can_memcmp_elements_with_pred<_Elem, _Elem, _Char_traits_eq<char_traits<_Elem>>> =
     _Can_memcmp_elements<_Elem, _Elem>;
 
 // library-provided char_traits::lt behaves like less<make_unsigned_t<_Elem>>
diff --git a/stl/inc/span b/stl/inc/span
index fe47c3e2d79..fe1e98744b3 100644
--- a/stl/inc/span
+++ b/stl/inc/span
@@ -224,16 +224,16 @@ class span;
 
 namespace ranges {
     template <class _Ty, size_t _Extent>
-    inline constexpr bool enable_view<span<_Ty, _Extent>> = true;
+    constexpr bool enable_view<span<_Ty, _Extent>> = true;
     template <class _Ty, size_t _Extent>
-    inline constexpr bool enable_borrowed_range<span<_Ty, _Extent>> = true;
+    constexpr bool enable_borrowed_range<span<_Ty, _Extent>> = true;
 } // namespace ranges
 
 template <class>
-inline constexpr bool _Is_span_v = false;
+constexpr bool _Is_span_v = false;
 
 template <class _Ty, size_t _Extent>
-inline constexpr bool _Is_span_v<span<_Ty, _Extent>> = true;
+constexpr bool _Is_span_v<span<_Ty, _Extent>> = true;
 
 // clang-format off
 template <class _It, class _Ty>
diff --git a/stl/inc/system_error b/stl/inc/system_error
index e422b473564..b8697d328cc 100644
--- a/stl/inc/system_error
+++ b/stl/inc/system_error
@@ -46,7 +46,7 @@ template <>
 struct is_error_code_enum<io_errc> : true_type {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;
+constexpr bool is_error_code_enum_v = is_error_code_enum<_Ty>::value;
 
 _EXPORT_STD template <class _Enum>
 struct is_error_condition_enum : false_type {};
@@ -55,7 +55,7 @@ template <>
 struct is_error_condition_enum<errc> : true_type {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Ty>::value;
+constexpr bool is_error_condition_enum_v = is_error_condition_enum<_Ty>::value;
 
 _EXPORT_STD class error_code;
 _EXPORT_STD class error_condition;
diff --git a/stl/inc/tuple b/stl/inc/tuple
index 66edcc20877..0d0cdb8f704 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -22,76 +22,75 @@ _STL_DISABLE_CLANG_WARNINGS
 
 _STD_BEGIN
 template <bool _Same, class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_conditional_explicit_v0 = false;
+constexpr bool _Tuple_conditional_explicit_v0 = false;
 
 template <class... _Dests, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_conditional_explicit_v0<true, tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_conditional_explicit_v0<true, tuple<_Dests...>, _Srcs...> =
     !conjunction_v<is_convertible<_Srcs, _Dests>...>;
 
 template <class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_conditional_explicit_v =
+constexpr bool _Tuple_conditional_explicit_v =
     _Tuple_conditional_explicit_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
 
 template <bool _Same, class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_constructible_v0 = false;
+constexpr bool _Tuple_constructible_v0 = false;
 
 template <class... _Dests, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
     conjunction_v<is_constructible<_Dests, _Srcs>...>;
 
 template <class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_constructible_v =
+constexpr bool _Tuple_constructible_v =
     _Tuple_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
 
 template <class _Dest, class... _Srcs>
 struct _Tuple_constructible_val : bool_constant<_Tuple_constructible_v<_Dest, _Srcs...>> {};
 
 template <bool _Same, class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_nothrow_constructible_v0 = false;
+constexpr bool _Tuple_nothrow_constructible_v0 = false;
 
 template <class... _Dests, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_nothrow_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_nothrow_constructible_v0<true, tuple<_Dests...>, _Srcs...> =
     conjunction_v<is_nothrow_constructible<_Dests, _Srcs>...>;
 
 template <class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_nothrow_constructible_v =
+constexpr bool _Tuple_nothrow_constructible_v =
     _Tuple_nothrow_constructible_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
 
 template <bool _Same, class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_assignable_v0 = false;
+constexpr bool _Tuple_assignable_v0 = false;
 
 template <class... _Dests, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
     conjunction_v<is_assignable<_Dests&, _Srcs>...>; // note _Dests& instead of _Dests
 
 #if _HAS_CXX23
 template <class... _Dests, class... _Srcs>
-inline constexpr bool _Tuple_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
     conjunction_v<is_assignable<const _Dests&, _Srcs>...>;
 #endif // _HAS_CXX23
 
 template <class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_assignable_v =
-    _Tuple_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
+constexpr bool _Tuple_assignable_v = _Tuple_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
 
 template <class _Dest, class... _Srcs>
 struct _Tuple_assignable_val : bool_constant<_Tuple_assignable_v<_Dest, _Srcs...>> {};
 
 template <bool _Same, class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_nothrow_assignable_v0 = false;
+constexpr bool _Tuple_nothrow_assignable_v0 = false;
 
 template <class... _Dests, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_nothrow_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_nothrow_assignable_v0<true, tuple<_Dests...>, _Srcs...> =
     conjunction_v<is_nothrow_assignable<_Dests&, _Srcs>...>; // note _Dests& instead of _Dests
 
 #if _HAS_CXX23
 template <class... _Dests, class... _Srcs>
-inline constexpr bool _Tuple_nothrow_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
+constexpr bool _Tuple_nothrow_assignable_v0<true, const tuple<_Dests...>, _Srcs...> =
     conjunction_v<is_nothrow_assignable<const _Dests&, _Srcs>...>;
 #endif // _HAS_CXX23
 
 template <class _Dest, class... _Srcs>
-_INLINE_VAR constexpr bool _Tuple_nothrow_assignable_v =
+constexpr bool _Tuple_nothrow_assignable_v =
     _Tuple_nothrow_assignable_v0<tuple_size_v<_Dest> == sizeof...(_Srcs), _Dest, _Srcs...>;
 
 // Constrain tuple's converting constructors
@@ -180,10 +179,10 @@ struct _Alloc_unpack_tuple_t {
 
 #if _HAS_CXX23
 template <class _Tuple, class _Other, class _Indices = make_index_sequence<tuple_size_v<_Tuple>>>
-inline constexpr bool _Can_construct_values_from_tuple_like_v = false;
+constexpr bool _Can_construct_values_from_tuple_like_v = false;
 
 template <class... _Types, class _Other, size_t... _Indices>
-inline constexpr bool _Can_construct_values_from_tuple_like_v<tuple<_Types...>, _Other, index_sequence<_Indices...>> =
+constexpr bool _Can_construct_values_from_tuple_like_v<tuple<_Types...>, _Other, index_sequence<_Indices...>> =
     conjunction_v<is_constructible<_Types, decltype(_STD get<_Indices>(_STD declval<_Other>()))>...>;
 
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, LLVM-59827 and VSO-1900279
@@ -1080,9 +1079,9 @@ constexpr decltype(auto) apply(_Callable&& _Obj, _Tuple&& _Tpl) noexcept(
 }
 
 template <class _Ty, class _Tuple, class _Seq = make_index_sequence<tuple_size_v<remove_reference_t<_Tuple>>>>
-inline constexpr bool _Can_make_from_tuple = false;
+constexpr bool _Can_make_from_tuple = false;
 template <class _Ty, class _Tuple, size_t... _Indices>
-inline constexpr bool _Can_make_from_tuple<_Ty, _Tuple, index_sequence<_Indices...>> =
+constexpr bool _Can_make_from_tuple<_Ty, _Tuple, index_sequence<_Indices...>> =
     is_constructible_v<_Ty, decltype(_STD get<_Indices>(_STD declval<_Tuple>()))...>;
 
 template <class _Ty, class _Tuple, size_t... _Indices>
diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index 9649fdde40b..4a93f007b28 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -29,7 +29,7 @@ _STL_DISABLE_CLANG_WARNINGS
 _STD_BEGIN
 template <class>
 // TRANSITION, CWG-2518: false value attached to a dependent name (for static_assert)
-_INLINE_VAR constexpr bool _Always_false = false;
+constexpr bool _Always_false = false;
 
 template <bool _First_value, class _First, class... _Rest>
 struct _Conjunction { // handle false trait or last trait
@@ -50,16 +50,16 @@ struct conjunction<_First, _Rest...> : _Conjunction<_First::value, _First, _Rest
 };
 
 _EXPORT_STD template <class... _Traits>
-_INLINE_VAR constexpr bool conjunction_v = conjunction<_Traits...>::value;
+constexpr bool conjunction_v = conjunction<_Traits...>::value;
 
 _EXPORT_STD template <class _Trait>
 struct negation : bool_constant<!static_cast<bool>(_Trait::value)> {}; // The negated result of _Trait
 
 _EXPORT_STD template <class _Trait>
-_INLINE_VAR constexpr bool negation_v = negation<_Trait>::value;
+constexpr bool negation_v = negation<_Trait>::value;
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_void_v = is_same_v<remove_cv_t<_Ty>, void>;
+constexpr bool is_void_v = is_same_v<remove_cv_t<_Ty>, void>;
 
 _EXPORT_STD template <class _Ty>
 struct is_void : bool_constant<is_void_v<_Ty>> {};
@@ -215,87 +215,87 @@ _EXPORT_STD template <class _Ty>
 using add_pointer_t = typename _Add_pointer<_Ty>::type;
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_array_v = false; // determine whether type argument is an array
+constexpr bool is_array_v = false; // determine whether type argument is an array
 
 template <class _Ty, size_t _Nx>
-_INLINE_VAR constexpr bool is_array_v<_Ty[_Nx]> = true;
+constexpr bool is_array_v<_Ty[_Nx]> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_array_v<_Ty[]> = true;
+constexpr bool is_array_v<_Ty[]> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_array : bool_constant<is_array_v<_Ty>> {};
 
 #if _HAS_CXX20
 _EXPORT_STD template <class>
-inline constexpr bool is_bounded_array_v = false;
+constexpr bool is_bounded_array_v = false;
 
 template <class _Ty, size_t _Nx>
-inline constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;
+constexpr bool is_bounded_array_v<_Ty[_Nx]> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_bounded_array : bool_constant<is_bounded_array_v<_Ty>> {};
 
 _EXPORT_STD template <class>
-inline constexpr bool is_unbounded_array_v = false;
+constexpr bool is_unbounded_array_v = false;
 
 template <class _Ty>
-inline constexpr bool is_unbounded_array_v<_Ty[]> = true;
+constexpr bool is_unbounded_array_v<_Ty[]> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_unbounded_array : bool_constant<is_unbounded_array_v<_Ty>> {};
 #endif // _HAS_CXX20
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_lvalue_reference_v = false; // determine whether type argument is an lvalue reference
+constexpr bool is_lvalue_reference_v = false; // determine whether type argument is an lvalue reference
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_lvalue_reference_v<_Ty&> = true;
+constexpr bool is_lvalue_reference_v<_Ty&> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_lvalue_reference : bool_constant<is_lvalue_reference_v<_Ty>> {};
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_rvalue_reference_v = false; // determine whether type argument is an rvalue reference
+constexpr bool is_rvalue_reference_v = false; // determine whether type argument is an rvalue reference
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_rvalue_reference_v<_Ty&&> = true;
+constexpr bool is_rvalue_reference_v<_Ty&&> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_rvalue_reference : bool_constant<is_rvalue_reference_v<_Ty>> {};
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_reference_v = false; // determine whether type argument is a reference
+constexpr bool is_reference_v = false; // determine whether type argument is a reference
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_reference_v<_Ty&> = true;
+constexpr bool is_reference_v<_Ty&> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_reference_v<_Ty&&> = true;
+constexpr bool is_reference_v<_Ty&&> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_reference : bool_constant<is_reference_v<_Ty>> {};
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer
+constexpr bool is_pointer_v = false; // determine whether _Ty is a pointer
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_pointer_v<_Ty*> = true;
+constexpr bool is_pointer_v<_Ty*> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_pointer_v<_Ty* const> = true;
+constexpr bool is_pointer_v<_Ty* const> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_pointer_v<_Ty* volatile> = true;
+constexpr bool is_pointer_v<_Ty* volatile> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_pointer_v<_Ty* const volatile> = true;
+constexpr bool is_pointer_v<_Ty* const volatile> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_pointer : bool_constant<is_pointer_v<_Ty>> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_null_pointer_v =
+constexpr bool is_null_pointer_v =
     is_same_v<remove_cv_t<_Ty>, nullptr_t>; // determine whether _Ty is cv-qualified nullptr_t
 
 _EXPORT_STD template <class _Ty>
@@ -305,16 +305,16 @@ _EXPORT_STD template <class _Ty>
 struct is_union : bool_constant<__is_union(_Ty)> {}; // determine whether _Ty is a union
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_union_v = __is_union(_Ty);
+constexpr bool is_union_v = __is_union(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_class : bool_constant<__is_class(_Ty)> {}; // determine whether _Ty is a class
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_class_v = __is_class(_Ty);
+constexpr bool is_class_v = __is_class(_Ty);
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;
+constexpr bool is_fundamental_v = is_arithmetic_v<_Ty> || is_void_v<_Ty> || is_null_pointer_v<_Ty>;
 
 _EXPORT_STD template <class _Ty>
 struct is_fundamental : bool_constant<is_fundamental_v<_Ty>> {}; // determine whether _Ty is a fundamental type
@@ -325,7 +325,7 @@ struct is_convertible : bool_constant<__is_convertible_to(_From, _To)> {
 };
 
 _EXPORT_STD template <class _From, class _To>
-_INLINE_VAR constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
+constexpr bool is_convertible_v = __is_convertible_to(_From, _To);
 
 #if !defined(__clang__) && !defined(__EDG__) // TRANSITION, DevCom-1627396
 template <class _Ty>
@@ -341,27 +341,27 @@ template <class _Ty>
 struct is_convertible<volatile _Ty&, const volatile _Ty&> : true_type {};
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_convertible_v<_Ty&, volatile _Ty&> = true;
+constexpr bool is_convertible_v<_Ty&, volatile _Ty&> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_convertible_v<volatile _Ty&, volatile _Ty&> = true;
+constexpr bool is_convertible_v<volatile _Ty&, volatile _Ty&> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_convertible_v<_Ty&, const volatile _Ty&> = true;
+constexpr bool is_convertible_v<_Ty&, const volatile _Ty&> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
+constexpr bool is_convertible_v<volatile _Ty&, const volatile _Ty&> = true;
 #endif // ^^^ workaround ^^^
 
 _EXPORT_STD template <class _Ty>
 struct is_enum : bool_constant<__is_enum(_Ty)> {}; // determine whether _Ty is an enumerated type
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_enum_v = __is_enum(_Ty);
+constexpr bool is_enum_v = __is_enum(_Ty);
 
 #if _HAS_CXX23
 _EXPORT_STD template <class _Ty>
-inline constexpr bool is_scoped_enum_v = conjunction_v<is_enum<_Ty>, negation<is_convertible<_Ty, int>>>;
+constexpr bool is_scoped_enum_v = conjunction_v<is_enum<_Ty>, negation<is_convertible<_Ty, int>>>;
 
 _EXPORT_STD template <class _Ty>
 struct is_scoped_enum : bool_constant<is_scoped_enum_v<_Ty>> {};
@@ -371,7 +371,7 @@ _EXPORT_STD template <class _Ty>
 struct is_compound : bool_constant<!is_fundamental_v<_Ty>> {}; // determine whether _Ty is a compound type
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_compound_v = !is_fundamental_v<_Ty>;
+constexpr bool is_compound_v = !is_fundamental_v<_Ty>;
 
 #define _EMIT_CDECL(FUNC, OPT1, OPT2, OPT3) FUNC(__cdecl, OPT1, OPT2, OPT3)
 
@@ -559,42 +559,42 @@ _NON_MEMBER_CALL(_IS_MEMFUNPTR_EXPLICIT_THIS_GUIDES, , , noexcept)
 
 #ifdef __clang__
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Ty);
+constexpr bool is_member_function_pointer_v = __is_member_function_pointer(_Ty);
 #else // ^^^ Clang / Other vvv
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_member_function_pointer_v = _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
+constexpr bool is_member_function_pointer_v = _Is_memfunptr<remove_cv_t<_Ty>>::_Bool_type::value;
 #endif // ^^^ Other ^^^
 
 _EXPORT_STD template <class _Ty>
 struct is_member_function_pointer : bool_constant<is_member_function_pointer_v<_Ty>> {};
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_const_v = false; // determine whether type argument is const qualified
+constexpr bool is_const_v = false; // determine whether type argument is const qualified
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_const_v<const _Ty> = true;
+constexpr bool is_const_v<const _Ty> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_const : bool_constant<is_const_v<_Ty>> {};
 
 _EXPORT_STD template <class>
-_INLINE_VAR constexpr bool is_volatile_v = false; // determine whether type argument is volatile qualified
+constexpr bool is_volatile_v = false; // determine whether type argument is volatile qualified
 
 template <class _Ty>
-_INLINE_VAR constexpr bool is_volatile_v<volatile _Ty> = true;
+constexpr bool is_volatile_v<volatile _Ty> = true;
 
 _EXPORT_STD template <class _Ty>
 struct is_volatile : bool_constant<is_volatile_v<_Ty>> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_function_v = // only function types and reference types can't be const qualified
+constexpr bool is_function_v = // only function types and reference types can't be const qualified
     !is_const_v<const _Ty> && !is_reference_v<_Ty>;
 
 _EXPORT_STD template <class _Ty>
 struct is_function : bool_constant<is_function_v<_Ty>> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_object_v = // only function types and reference types can't be const qualified
+constexpr bool is_object_v = // only function types and reference types can't be const qualified
     is_const_v<const _Ty> && !is_void_v<_Ty>;
 
 _EXPORT_STD template <class _Ty>
@@ -613,10 +613,10 @@ struct _Is_member_object_pointer<_Ty1 _Ty2::*> {
 
 #ifdef __clang__
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Ty);
+constexpr bool is_member_object_pointer_v = __is_member_object_pointer(_Ty);
 #else // ^^^ Clang / Other vvv
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_member_object_pointer_v = _Is_member_object_pointer<remove_cv_t<_Ty>>::value;
+constexpr bool is_member_object_pointer_v = _Is_member_object_pointer<remove_cv_t<_Ty>>::value;
 #endif // ^^^ Other ^^^
 
 _EXPORT_STD template <class _Ty>
@@ -624,17 +624,17 @@ struct is_member_object_pointer : bool_constant<is_member_object_pointer_v<_Ty>>
 
 #ifdef __clang__
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_member_pointer_v = __is_member_pointer(_Ty);
+constexpr bool is_member_pointer_v = __is_member_pointer(_Ty);
 #else // ^^^ Clang / Other vvv
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_member_pointer_v = is_member_object_pointer_v<_Ty> || is_member_function_pointer_v<_Ty>;
+constexpr bool is_member_pointer_v = is_member_object_pointer_v<_Ty> || is_member_function_pointer_v<_Ty>;
 #endif // ^^^ Other ^^^
 
 _EXPORT_STD template <class _Ty>
 struct is_member_pointer : bool_constant<is_member_pointer_v<_Ty>> {}; // determine whether _Ty is a pointer to member
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_scalar_v = // determine whether _Ty is a scalar type
+constexpr bool is_scalar_v = // determine whether _Ty is a scalar type
     is_arithmetic_v<_Ty> || is_enum_v<_Ty> || is_pointer_v<_Ty> || is_member_pointer_v<_Ty> || is_null_pointer_v<_Ty>;
 
 _EXPORT_STD template <class _Ty>
@@ -644,37 +644,37 @@ _EXPORT_STD template <class _Ty>
 struct _CXX20_DEPRECATE_IS_POD is_pod : bool_constant<__is_pod(_Ty)> {}; // determine whether _Ty is a POD type
 
 _EXPORT_STD template <class _Ty>
-_CXX20_DEPRECATE_IS_POD _INLINE_VAR constexpr bool is_pod_v = __is_pod(_Ty);
+_CXX20_DEPRECATE_IS_POD constexpr bool is_pod_v = __is_pod(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_empty : bool_constant<__is_empty(_Ty)> {}; // determine whether _Ty is an empty class
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_empty_v = __is_empty(_Ty);
+constexpr bool is_empty_v = __is_empty(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_polymorphic : bool_constant<__is_polymorphic(_Ty)> {}; // determine whether _Ty is a polymorphic type
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);
+constexpr bool is_polymorphic_v = __is_polymorphic(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_abstract : bool_constant<__is_abstract(_Ty)> {}; // determine whether _Ty is an abstract class
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_abstract_v = __is_abstract(_Ty);
+constexpr bool is_abstract_v = __is_abstract(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_final : bool_constant<__is_final(_Ty)> {}; // determine whether _Ty is a final class
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_final_v = __is_final(_Ty);
+constexpr bool is_final_v = __is_final(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_standard_layout : bool_constant<__is_standard_layout(_Ty)> {}; // determine whether _Ty is standard layout
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);
+constexpr bool is_standard_layout_v = __is_standard_layout(_Ty);
 
 #if _HAS_DEPRECATED_IS_LITERAL_TYPE
 _EXPORT_STD template <class _Ty>
@@ -683,7 +683,7 @@ struct _CXX17_DEPRECATE_IS_LITERAL_TYPE is_literal_type : bool_constant<__is_lit
 };
 
 _EXPORT_STD template <class _Ty>
-_CXX17_DEPRECATE_IS_LITERAL_TYPE _INLINE_VAR constexpr bool is_literal_type_v = __is_literal_type(_Ty);
+_CXX17_DEPRECATE_IS_LITERAL_TYPE constexpr bool is_literal_type_v = __is_literal_type(_Ty);
 #endif // _HAS_DEPRECATED_IS_LITERAL_TYPE
 
 #if 1 // TRANSITION, VSO-119526 and LLVM-41915
@@ -693,13 +693,13 @@ struct is_trivial : bool_constant<__is_trivially_constructible(_Ty) && __is_triv
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivial_v = __is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty);
+constexpr bool is_trivial_v = __is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty);
 #else // ^^^ workaround / no workaround vvv
 _EXPORT_STD template <class _Ty>
 struct is_trivial : bool_constant<__is_trivial(_Ty)> {}; // determine whether _Ty is a trivial type
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivial_v = __is_trivial(_Ty);
+constexpr bool is_trivial_v = __is_trivial(_Ty);
 #endif // ^^^ no workaround ^^^
 
 _EXPORT_STD template <class _Ty>
@@ -708,7 +708,7 @@ struct is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);
+constexpr bool is_trivially_copyable_v = __is_trivially_copyable(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct has_virtual_destructor : bool_constant<__has_virtual_destructor(_Ty)> {
@@ -716,7 +716,7 @@ struct has_virtual_destructor : bool_constant<__has_virtual_destructor(_Ty)> {
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);
+constexpr bool has_virtual_destructor_v = __has_virtual_destructor(_Ty);
 
 #if _HAS_CXX17
 _EXPORT_STD template <class _Ty>
@@ -725,14 +725,14 @@ struct has_unique_object_representations : bool_constant<__has_unique_object_rep
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Ty);
+constexpr bool has_unique_object_representations_v = __has_unique_object_representations(_Ty);
 
 #ifdef __EDG__ // TRANSITION, VSO-1690654
 template <class _Ty>
 struct _Is_aggregate_impl : bool_constant<__is_aggregate(_Ty)> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_aggregate_v = disjunction_v<is_array<_Ty>, _Is_aggregate_impl<_Ty>>;
+constexpr bool is_aggregate_v = disjunction_v<is_array<_Ty>, _Is_aggregate_impl<_Ty>>;
 
 _EXPORT_STD template <class _Ty>
 struct is_aggregate : bool_constant<is_aggregate_v<_Ty>> {};
@@ -741,7 +741,7 @@ _EXPORT_STD template <class _Ty>
 struct is_aggregate : bool_constant<__is_aggregate(_Ty)> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_aggregate_v = __is_aggregate(_Ty);
+constexpr bool is_aggregate_v = __is_aggregate(_Ty);
 #endif // ^^^ no workaround ^^^
 #endif // _HAS_CXX17
 
@@ -751,7 +751,7 @@ struct is_constructible : bool_constant<__is_constructible(_Ty, _Args...)> {
 };
 
 _EXPORT_STD template <class _Ty, class... _Args>
-_INLINE_VAR constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);
+constexpr bool is_constructible_v = __is_constructible(_Ty, _Args...);
 
 _EXPORT_STD template <class _Ty>
 struct is_copy_constructible : bool_constant<__is_constructible(_Ty, add_lvalue_reference_t<const _Ty>)> {
@@ -759,7 +759,7 @@ struct is_copy_constructible : bool_constant<__is_constructible(_Ty, add_lvalue_
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_copy_constructible_v = __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+constexpr bool is_copy_constructible_v = __is_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
 
 _EXPORT_STD template <class _Ty>
 struct is_default_constructible : bool_constant<__is_constructible(_Ty)> {
@@ -767,7 +767,7 @@ struct is_default_constructible : bool_constant<__is_constructible(_Ty)> {
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_default_constructible_v = __is_constructible(_Ty);
+constexpr bool is_default_constructible_v = __is_constructible(_Ty);
 
 template <class _Ty, class = void>
 struct _Is_implicitly_default_constructible : false_type {
@@ -787,13 +787,13 @@ struct is_move_constructible : bool_constant<__is_constructible(_Ty, _Ty)> {
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);
+constexpr bool is_move_constructible_v = __is_constructible(_Ty, _Ty);
 
 _EXPORT_STD template <class _To, class _From>
 struct is_assignable : bool_constant<__is_assignable(_To, _From)> {}; // determine whether _From can be assigned to _To
 
 _EXPORT_STD template <class _To, class _From>
-_INLINE_VAR constexpr bool is_assignable_v = __is_assignable(_To, _From);
+constexpr bool is_assignable_v = __is_assignable(_To, _From);
 
 #if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 template <class _To, class _From>
@@ -810,8 +810,7 @@ struct is_copy_assignable
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_copy_assignable_v =
-    __is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
+constexpr bool is_copy_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 
 #if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 template <class _Ty>
@@ -820,14 +819,14 @@ struct _Is_copy_assignable_no_precondition_check
           add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>)> {};
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_copy_assignable_unchecked_v =
+constexpr bool _Is_copy_assignable_unchecked_v =
     __is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 #else // ^^^ Use intrinsic / intrinsic not supported vvv
 template <class _Ty>
 using _Is_copy_assignable_no_precondition_check = is_copy_assignable<_Ty>;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_copy_assignable_unchecked_v = is_copy_assignable_v<_Ty>;
+constexpr bool _Is_copy_assignable_unchecked_v = is_copy_assignable_v<_Ty>;
 #endif // ^^^ intrinsic not supported ^^^
 
 _EXPORT_STD template <class _Ty>
@@ -836,7 +835,7 @@ struct is_move_assignable : bool_constant<__is_assignable(add_lvalue_reference_t
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_move_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+constexpr bool is_move_assignable_v = __is_assignable(add_lvalue_reference_t<_Ty>, _Ty);
 
 #if defined(_IS_ASSIGNABLE_NOCHECK_SUPPORTED) && !defined(__CUDACC__)
 template <class _Ty>
@@ -844,14 +843,14 @@ struct _Is_move_assignable_no_precondition_check
     : bool_constant<__is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty)> {};
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_move_assignable_unchecked_v =
+constexpr bool _Is_move_assignable_unchecked_v =
     __is_assignable_no_precondition_check(add_lvalue_reference_t<_Ty>, _Ty);
 #else // ^^^ Use intrinsic / intrinsic not supported vvv
 template <class _Ty>
 using _Is_move_assignable_no_precondition_check = is_move_assignable<_Ty>;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_move_assignable_unchecked_v = is_move_assignable_v<_Ty>;
+constexpr bool _Is_move_assignable_unchecked_v = is_move_assignable_v<_Ty>;
 #endif // ^^^ intrinsic not supported ^^^
 
 _EXPORT_STD template <class _Ty>
@@ -860,7 +859,7 @@ struct is_destructible : bool_constant<__is_destructible(_Ty)> {
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_destructible_v = __is_destructible(_Ty);
+constexpr bool is_destructible_v = __is_destructible(_Ty);
 
 _EXPORT_STD template <class _Ty, class... _Args>
 struct is_trivially_constructible : bool_constant<__is_trivially_constructible(_Ty, _Args...)> {
@@ -868,7 +867,7 @@ struct is_trivially_constructible : bool_constant<__is_trivially_constructible(_
 };
 
 _EXPORT_STD template <class _Ty, class... _Args>
-_INLINE_VAR constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Ty, _Args...);
+constexpr bool is_trivially_constructible_v = __is_trivially_constructible(_Ty, _Args...);
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_copy_constructible
@@ -877,8 +876,7 @@ struct is_trivially_copy_constructible
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_copy_constructible_v =
-    __is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+constexpr bool is_trivially_copy_constructible_v = __is_trivially_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_default_constructible : bool_constant<__is_trivially_constructible(_Ty)> {
@@ -886,7 +884,7 @@ struct is_trivially_default_constructible : bool_constant<__is_trivially_constru
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Ty);
+constexpr bool is_trivially_default_constructible_v = __is_trivially_constructible(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_move_constructible : bool_constant<__is_trivially_constructible(_Ty, _Ty)> {
@@ -894,7 +892,7 @@ struct is_trivially_move_constructible : bool_constant<__is_trivially_constructi
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Ty, _Ty);
+constexpr bool is_trivially_move_constructible_v = __is_trivially_constructible(_Ty, _Ty);
 
 _EXPORT_STD template <class _To, class _From>
 struct is_trivially_assignable : bool_constant<__is_trivially_assignable(_To, _From)> {
@@ -902,7 +900,7 @@ struct is_trivially_assignable : bool_constant<__is_trivially_assignable(_To, _F
 };
 
 _EXPORT_STD template <class _To, class _From>
-_INLINE_VAR constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);
+constexpr bool is_trivially_assignable_v = __is_trivially_assignable(_To, _From);
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_copy_assignable
@@ -911,7 +909,7 @@ struct is_trivially_copy_assignable
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_copy_assignable_v =
+constexpr bool is_trivially_copy_assignable_v =
     __is_trivially_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 
 _EXPORT_STD template <class _Ty>
@@ -920,7 +918,7 @@ struct is_trivially_move_assignable : bool_constant<__is_trivially_assignable(ad
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+constexpr bool is_trivially_move_assignable_v = __is_trivially_assignable(add_lvalue_reference_t<_Ty>, _Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_destructible : bool_constant<__is_trivially_destructible(_Ty)> {
@@ -928,7 +926,7 @@ struct is_trivially_destructible : bool_constant<__is_trivially_destructible(_Ty
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);
+constexpr bool is_trivially_destructible_v = __is_trivially_destructible(_Ty);
 
 _EXPORT_STD template <class _Ty, class... _Args>
 struct is_nothrow_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Args...)> {
@@ -936,7 +934,7 @@ struct is_nothrow_constructible : bool_constant<__is_nothrow_constructible(_Ty,
 };
 
 _EXPORT_STD template <class _Ty, class... _Args>
-_INLINE_VAR constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Ty, _Args...);
+constexpr bool is_nothrow_constructible_v = __is_nothrow_constructible(_Ty, _Args...);
 
 _EXPORT_STD template <class _Ty>
 struct is_nothrow_copy_constructible
@@ -946,8 +944,7 @@ struct is_nothrow_copy_constructible
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_copy_constructible_v =
-    __is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
+constexpr bool is_nothrow_copy_constructible_v = __is_nothrow_constructible(_Ty, add_lvalue_reference_t<const _Ty>);
 
 _EXPORT_STD template <class _Ty>
 struct is_nothrow_default_constructible : bool_constant<__is_nothrow_constructible(_Ty)> {
@@ -955,7 +952,7 @@ struct is_nothrow_default_constructible : bool_constant<__is_nothrow_constructib
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);
+constexpr bool is_nothrow_default_constructible_v = __is_nothrow_constructible(_Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_nothrow_move_constructible : bool_constant<__is_nothrow_constructible(_Ty, _Ty)> {
@@ -963,7 +960,7 @@ struct is_nothrow_move_constructible : bool_constant<__is_nothrow_constructible(
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Ty, _Ty);
+constexpr bool is_nothrow_move_constructible_v = __is_nothrow_constructible(_Ty, _Ty);
 
 _EXPORT_STD template <class _To, class _From>
 struct is_nothrow_assignable : bool_constant<__is_nothrow_assignable(_To, _From)> {
@@ -971,7 +968,7 @@ struct is_nothrow_assignable : bool_constant<__is_nothrow_assignable(_To, _From)
 };
 
 _EXPORT_STD template <class _To, class _From>
-_INLINE_VAR constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);
+constexpr bool is_nothrow_assignable_v = __is_nothrow_assignable(_To, _From);
 
 _EXPORT_STD template <class _Ty>
 struct is_nothrow_copy_assignable
@@ -980,7 +977,7 @@ struct is_nothrow_copy_assignable
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_copy_assignable_v =
+constexpr bool is_nothrow_copy_assignable_v =
     __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, add_lvalue_reference_t<const _Ty>);
 
 _EXPORT_STD template <class _Ty>
@@ -989,7 +986,7 @@ struct is_nothrow_move_assignable : bool_constant<__is_nothrow_assignable(add_lv
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);
+constexpr bool is_nothrow_move_assignable_v = __is_nothrow_assignable(add_lvalue_reference_t<_Ty>, _Ty);
 
 _EXPORT_STD template <class _Ty>
 struct is_nothrow_destructible : bool_constant<__is_nothrow_destructible(_Ty)> {
@@ -998,7 +995,7 @@ struct is_nothrow_destructible : bool_constant<__is_nothrow_destructible(_Ty)> {
 };
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);
+constexpr bool is_nothrow_destructible_v = __is_nothrow_destructible(_Ty);
 
 template <class _Ty, bool = is_integral_v<_Ty>>
 struct _Sign_base { // determine whether integral type _Ty is signed or unsigned
@@ -1019,16 +1016,16 @@ _EXPORT_STD template <class _Ty>
 struct is_signed : bool_constant<_Sign_base<_Ty>::_Signed> {}; // determine whether _Ty is a signed type
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;
+constexpr bool is_signed_v = _Sign_base<_Ty>::_Signed;
 
 _EXPORT_STD template <class _Ty>
 struct is_unsigned : bool_constant<_Sign_base<_Ty>::_Unsigned> {}; // determine whether _Ty is an unsigned type
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_unsigned_v = _Sign_base<_Ty>::_Unsigned;
+constexpr bool is_unsigned_v = _Sign_base<_Ty>::_Unsigned;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;
+constexpr bool _Is_nonbool_integral = is_integral_v<_Ty> && !is_same_v<remove_cv_t<_Ty>, bool>;
 
 template <bool>
 struct _Select { // Select between aliases that extract either their first or second parameter
@@ -1140,7 +1137,7 @@ _EXPORT_STD template <class _Ty>
 struct alignment_of : integral_constant<size_t, alignof(_Ty)> {}; // determine alignment of _Ty
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr size_t alignment_of_v = alignof(_Ty);
+constexpr size_t alignment_of_v = alignof(_Ty);
 
 template <class _Ty, size_t _Len>
 union _Align_type { // union with size _Len bytes and alignment of _Ty
@@ -1261,28 +1258,28 @@ _EXPORT_STD template <class _Ty>
 using underlying_type_t = typename _Underlying_type<_Ty>::type;
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr size_t rank_v = 0; // determine number of dimensions of array _Ty
+constexpr size_t rank_v = 0; // determine number of dimensions of array _Ty
 
 template <class _Ty, size_t _Nx>
-_INLINE_VAR constexpr size_t rank_v<_Ty[_Nx]> = rank_v<_Ty> + 1;
+constexpr size_t rank_v<_Ty[_Nx]> = rank_v<_Ty> + 1;
 
 template <class _Ty>
-_INLINE_VAR constexpr size_t rank_v<_Ty[]> = rank_v<_Ty> + 1;
+constexpr size_t rank_v<_Ty[]> = rank_v<_Ty> + 1;
 
 _EXPORT_STD template <class _Ty>
 struct rank : integral_constant<size_t, rank_v<_Ty>> {};
 
 _EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
-_INLINE_VAR constexpr size_t extent_v = 0; // determine extent of dimension _Ix of array _Ty
+constexpr size_t extent_v = 0; // determine extent of dimension _Ix of array _Ty
 
 template <class _Ty, size_t _Nx>
-_INLINE_VAR constexpr size_t extent_v<_Ty[_Nx], 0> = _Nx;
+constexpr size_t extent_v<_Ty[_Nx], 0> = _Nx;
 
 template <class _Ty, unsigned int _Ix, size_t _Nx>
-_INLINE_VAR constexpr size_t extent_v<_Ty[_Nx], _Ix> = extent_v<_Ty, _Ix - 1>;
+constexpr size_t extent_v<_Ty[_Nx], _Ix> = extent_v<_Ty, _Ix - 1>;
 
 template <class _Ty, unsigned int _Ix>
-_INLINE_VAR constexpr size_t extent_v<_Ty[], _Ix> = extent_v<_Ty, _Ix - 1>;
+constexpr size_t extent_v<_Ty[], _Ix> = extent_v<_Ty, _Ix - 1>;
 
 _EXPORT_STD template <class _Ty, unsigned int _Ix = 0>
 struct extent : integral_constant<size_t, extent_v<_Ty, _Ix>> {};
@@ -1293,7 +1290,7 @@ struct is_base_of : bool_constant<__is_base_of(_Base, _Derived)> {
 };
 
 _EXPORT_STD template <class _Base, class _Derived>
-_INLINE_VAR constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
+constexpr bool is_base_of_v = __is_base_of(_Base, _Derived);
 
 _EXPORT_STD template <class _Ty>
 struct decay { // determines decayed version of _Ty
@@ -1525,9 +1522,9 @@ using type_identity_t = type_identity<_Ty>::type;
 #endif // _HAS_CXX20
 
 template <class _Type, template <class...> class _Template>
-_INLINE_VAR constexpr bool _Is_specialization_v = false; // true if and only if _Type is a specialization of _Template
+constexpr bool _Is_specialization_v = false; // true if and only if _Type is a specialization of _Template
 template <template <class...> class _Template, class... _Types>
-_INLINE_VAR constexpr bool _Is_specialization_v<_Template<_Types...>, _Template> = true;
+constexpr bool _Is_specialization_v<_Template<_Types...>, _Template> = true;
 
 template <class _Type, template <class...> class _Template>
 struct _Is_specialization : bool_constant<_Is_specialization_v<_Type, _Template>> {};
@@ -1740,15 +1737,15 @@ constexpr auto invoke(_Callable&& _Obj, _Ty1&& _Arg1, _Types2&&... _Args2) noexc
 #pragma warning(disable : 4365) // '%s': conversion from '%s' to '%s', signed/unsigned mismatch (/Wall)
 
 template <class _From, class _To, bool = is_convertible_v<_From, _To>, bool = is_void_v<_To>>
-_INLINE_VAR constexpr bool _Is_nothrow_convertible_v = noexcept(_STD _Fake_copy_init<_To>(_STD declval<_From>()));
+constexpr bool _Is_nothrow_convertible_v = noexcept(_STD _Fake_copy_init<_To>(_STD declval<_From>()));
 
 #pragma warning(pop)
 
 template <class _From, class _To, bool _IsVoid>
-_INLINE_VAR constexpr bool _Is_nothrow_convertible_v<_From, _To, false, _IsVoid> = false;
+constexpr bool _Is_nothrow_convertible_v<_From, _To, false, _IsVoid> = false;
 
 template <class _From, class _To>
-_INLINE_VAR constexpr bool _Is_nothrow_convertible_v<_From, _To, true, true> = true;
+constexpr bool _Is_nothrow_convertible_v<_From, _To, true, true> = true;
 
 template <class _From, class _To>
 struct _Is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {
@@ -1757,7 +1754,7 @@ struct _Is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From,
 
 #if _HAS_CXX20
 _EXPORT_STD template <class _From, class _To>
-inline constexpr bool is_nothrow_convertible_v = _Is_nothrow_convertible_v<_From, _To>;
+constexpr bool is_nothrow_convertible_v = _Is_nothrow_convertible_v<_From, _To>;
 
 _EXPORT_STD template <class _From, class _To>
 struct is_nothrow_convertible : bool_constant<_Is_nothrow_convertible_v<_From, _To>> {};
@@ -1878,7 +1875,7 @@ struct is_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_invocable
 };
 
 _EXPORT_STD template <class _Callable, class... _Args>
-inline constexpr bool is_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_invocable::value;
+constexpr bool is_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_invocable::value;
 
 _EXPORT_STD template <class _Callable, class... _Args>
 struct is_nothrow_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable {
@@ -1886,7 +1883,7 @@ struct is_nothrow_invocable : _Select_invoke_traits<_Callable, _Args...>::_Is_no
 };
 
 _EXPORT_STD template <class _Callable, class... _Args>
-inline constexpr bool is_nothrow_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable::value;
+constexpr bool is_nothrow_invocable_v = _Select_invoke_traits<_Callable, _Args...>::_Is_nothrow_invocable::value;
 
 _EXPORT_STD template <class _Rx, class _Callable, class... _Args>
 struct is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
@@ -1894,7 +1891,7 @@ struct is_invocable_r : _Is_invocable_r_<_Rx, _Callable, _Args...> {
 };
 
 _EXPORT_STD template <class _Rx, class _Callable, class... _Args>
-inline constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;
+constexpr bool is_invocable_r_v = _Is_invocable_r_<_Rx, _Callable, _Args...>::value;
 
 _EXPORT_STD template <class _Rx, class _Callable, class... _Args>
 struct is_nothrow_invocable_r : _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx> {
@@ -1902,7 +1899,7 @@ struct is_nothrow_invocable_r : _Select_invoke_traits<_Callable, _Args...>::temp
 };
 
 _EXPORT_STD template <class _Rx, class _Callable, class... _Args>
-inline constexpr bool is_nothrow_invocable_r_v =
+constexpr bool is_nothrow_invocable_r_v =
     _Select_invoke_traits<_Callable, _Args...>::template _Is_nothrow_invocable_r<_Rx>::value;
 #endif // _HAS_CXX17
 
@@ -1912,13 +1909,13 @@ _EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_layout_compatible : bool_constant<__is_layout_compatible(_Ty1, _Ty2)> {};
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
-inline constexpr bool is_layout_compatible_v = __is_layout_compatible(_Ty1, _Ty2);
+constexpr bool is_layout_compatible_v = __is_layout_compatible(_Ty1, _Ty2);
 
 _EXPORT_STD template <class _Base, class _Derived>
 struct is_pointer_interconvertible_base_of : bool_constant<__is_pointer_interconvertible_base_of(_Base, _Derived)> {};
 
 _EXPORT_STD template <class _Base, class _Derived>
-inline constexpr bool is_pointer_interconvertible_base_of_v = __is_pointer_interconvertible_base_of(_Base, _Derived);
+constexpr bool is_pointer_interconvertible_base_of_v = __is_pointer_interconvertible_base_of(_Base, _Derived);
 
 _EXPORT_STD template <class _ClassTy, class _MemberTy>
 _NODISCARD constexpr bool is_pointer_interconvertible_with_class(_MemberTy _ClassTy::*_Pm) noexcept {
@@ -2157,14 +2154,14 @@ struct is_swappable_with : _Is_swappable_with<_Ty1, _Ty2>::type {
 };
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
-inline constexpr bool is_swappable_with_v =
+constexpr bool is_swappable_with_v =
     conjunction_v<_Swappable_with_helper<_Ty1, _Ty2>, _Swappable_with_helper<_Ty2, _Ty1>>;
 
 _EXPORT_STD template <class _Ty>
 struct is_swappable : _Is_swappable<_Ty>::type {}; // Determine if _Ty lvalues satisfy is_swappable_with
 
 _EXPORT_STD template <class _Ty>
-inline constexpr bool is_swappable_v = _Is_swappable<_Ty>::value;
+constexpr bool is_swappable_v = _Is_swappable<_Ty>::value;
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_nothrow_swappable_with : _Is_nothrow_swappable_with<_Ty1, _Ty2>::type {
@@ -2173,7 +2170,7 @@ struct is_nothrow_swappable_with : _Is_nothrow_swappable_with<_Ty1, _Ty2>::type
 };
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
-inline constexpr bool is_nothrow_swappable_with_v = _Is_nothrow_swappable_with<_Ty1, _Ty2>::value;
+constexpr bool is_nothrow_swappable_with_v = _Is_nothrow_swappable_with<_Ty1, _Ty2>::value;
 
 _EXPORT_STD template <class _Ty>
 struct is_nothrow_swappable : _Is_nothrow_swappable<_Ty>::type {
@@ -2181,7 +2178,7 @@ struct is_nothrow_swappable : _Is_nothrow_swappable<_Ty>::type {
 };
 
 _EXPORT_STD template <class _Ty>
-inline constexpr bool is_nothrow_swappable_v = _Is_nothrow_swappable<_Ty>::value;
+constexpr bool is_nothrow_swappable_v = _Is_nothrow_swappable<_Ty>::value;
 #endif // _HAS_CXX17
 
 namespace _Has_ADL_swap_detail {
@@ -2199,7 +2196,7 @@ namespace _Has_ADL_swap_detail {
 using _Has_ADL_swap_detail::_Has_ADL_swap;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_trivially_swappable_v = conjunction_v<is_trivially_destructible<_Ty>,
+constexpr bool _Is_trivially_swappable_v = conjunction_v<is_trivially_destructible<_Ty>,
     is_trivially_move_constructible<_Ty>, is_trivially_move_assignable<_Ty>, negation<_Has_ADL_swap<_Ty>>>;
 
 #ifdef __cpp_lib_byte
diff --git a/stl/inc/utility b/stl/inc/utility
index 458091fb313..cd224102e59 100644
--- a/stl/inc/utility
+++ b/stl/inc/utility
@@ -147,7 +147,7 @@ _EXPORT_STD template <class _Tuple>
 struct tuple_size;
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr size_t tuple_size_v = tuple_size<_Ty>::value;
+constexpr size_t tuple_size_v = tuple_size<_Ty>::value;
 
 _EXPORT_STD template <size_t _Index, class _Tuple>
 struct tuple_element;
@@ -187,17 +187,17 @@ template <class _Ty1, class _Ty2>
 concept _Different_from = !same_as<remove_cvref_t<_Ty1>, remove_cvref_t<_Ty2>>;
 
 template <class>
-inline constexpr bool _Is_std_array_v = false;
+constexpr bool _Is_std_array_v = false;
 
 template <class _Ty, size_t _Size>
-inline constexpr bool _Is_std_array_v<array<_Ty, _Size>> = true;
+constexpr bool _Is_std_array_v<array<_Ty, _Size>> = true;
 
 template <class>
-inline constexpr bool _Is_subrange_v = false;
+constexpr bool _Is_subrange_v = false;
 
 #if _HAS_CXX23
 template <class _Ty>
-inline constexpr bool _Tuple_like_impl =
+constexpr bool _Tuple_like_impl =
     _Is_specialization_v<_Ty, tuple> || _Is_specialization_v<_Ty, pair> || _Is_std_array_v<_Ty> || _Is_subrange_v<_Ty>;
 
 template <class _Ty>
@@ -778,27 +778,27 @@ struct in_place_type_t { // tag that selects a type to construct in place
     explicit in_place_type_t() = default;
 };
 _EXPORT_STD template <class _Ty>
-inline constexpr in_place_type_t<_Ty> in_place_type{};
+constexpr in_place_type_t<_Ty> in_place_type{};
 
 _EXPORT_STD template <size_t>
 struct in_place_index_t { // tag that selects the index of a type to construct in place
     explicit in_place_index_t() = default;
 };
 _EXPORT_STD template <size_t _Idx>
-inline constexpr in_place_index_t<_Idx> in_place_index{};
+constexpr in_place_index_t<_Idx> in_place_index{};
 #endif // _HAS_CXX17
 
 #if _HAS_CXX20
 template <class _Ty>
-inline constexpr bool _Is_standard_integer = is_integral_v<_Ty>
-                                          && !_Is_any_of_v<remove_cv_t<_Ty>, bool, char,
+constexpr bool _Is_standard_integer = is_integral_v<_Ty>
+                                   && !_Is_any_of_v<remove_cv_t<_Ty>, bool, char,
 #ifdef _NATIVE_WCHAR_T_DEFINED
-                                              wchar_t,
+                                       wchar_t,
 #endif // _NATIVE_WCHAR_T_DEFINED
 #ifdef __cpp_char8_t
-                                              char8_t,
+                                       char8_t,
 #endif // defined(__cpp_char8_t)
-                                              char16_t, char32_t>;
+                                       char16_t, char32_t>;
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
 _NODISCARD constexpr bool cmp_equal(const _Ty1 _Left, const _Ty2 _Right) noexcept {
diff --git a/stl/inc/variant b/stl/inc/variant
index 6e36ee39ed9..2690217f61b 100644
--- a/stl/inc/variant
+++ b/stl/inc/variant
@@ -333,7 +333,7 @@ struct _CXX20_DEPRECATE_VOLATILE variant_size<volatile _Ty> : variant_size<_Ty>:
 template <class _Ty>
 struct _CXX20_DEPRECATE_VOLATILE variant_size<const volatile _Ty> : variant_size<_Ty>::type {};
 _EXPORT_STD template <class _Ty>
-inline constexpr size_t variant_size_v = variant_size<_Ty>::value;
+constexpr size_t variant_size_v = variant_size<_Ty>::value;
 
 template <class... _Types>
 struct variant_size<variant<_Types...>> : integral_constant<size_t, sizeof...(_Types)> {};
@@ -580,10 +580,10 @@ _NODISCARD constexpr _Variant_raw_visit_t<_Fn, _Storage> _Variant_raw_visit_valu
 }
 
 template <class _Fn, class _Storage, class _Indices = make_index_sequence<remove_reference_t<_Storage>::_Size>>
-inline constexpr bool _Variant_raw_visit_noexcept = false;
+constexpr bool _Variant_raw_visit_noexcept = false;
 
 template <class _Fn, class _Storage, size_t... _Idxs>
-inline constexpr bool _Variant_raw_visit_noexcept<_Fn, _Storage, index_sequence<_Idxs...>> =
+constexpr bool _Variant_raw_visit_noexcept<_Fn, _Storage, index_sequence<_Idxs...>> =
     conjunction_v<is_nothrow_invocable<_Fn, _Tagged<_Storage&&, variant_npos>>,
         is_nothrow_invocable<_Fn, _Variant_tagged_ref_t<_Storage, _Idxs>>...>;
 
@@ -720,7 +720,7 @@ struct _Variant_construct_visitor { // visitor that constructs the same alternat
 };
 
 template <class _Target, class... _Types>
-inline constexpr bool _Variant_should_directly_construct_v =
+constexpr bool _Variant_should_directly_construct_v =
     disjunction_v<is_nothrow_constructible<_Target, _Types...>, negation<is_nothrow_move_constructible<_Target>>>;
 
 template <class... _Types>
@@ -957,9 +957,9 @@ using _Variant_init_index = _Meta_front<typename _Variant_init_helper<void, _Ty,
 #endif // ^^^ not Clang ^^^
 
 template <class>
-inline constexpr bool _Is_in_place_index_specialization = false;
+constexpr bool _Is_in_place_index_specialization = false;
 template <size_t _Idx>
-inline constexpr bool _Is_in_place_index_specialization<in_place_index_t<_Idx>> = true;
+constexpr bool _Is_in_place_index_specialization<in_place_index_t<_Idx>> = true;
 
 _EXPORT_STD template <class... _Types>
 class variant : private _SMF_control<_Variant_destroy_layer<_Types...>, _Types...> { // discriminated union
@@ -1399,7 +1399,7 @@ _NODISCARD constexpr common_comparison_category_t<compare_three_way_result_t<_Ty
 #endif // _HAS_CXX20
 
 template <class... _Variants>
-inline constexpr size_t _Variant_total_states =
+constexpr size_t _Variant_total_states =
     (size_t{1} * ... * (variant_size_v<_Variants> + 1)); // +1 to account for the valueless state
 
 _NODISCARD constexpr size_t _Variant_visit_index1(const size_t _Acc) noexcept {
@@ -1567,29 +1567,29 @@ constexpr _Ret _Visit_impl(_Callable&& _Obj, _Variants&&... _Args) {
 }
 
 template <class _Expected, class _Callable, class _ArgList, class... _Variants>
-inline constexpr bool _Variant_all_visit_results_same = false;
+constexpr bool _Variant_all_visit_results_same = false;
 
 template <class _Expected, class _Callable, class... _Args>
-inline constexpr bool _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>> =
+constexpr bool _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>> =
     is_same_v<decltype(_STD invoke(_STD declval<_Callable>(), _STD declval<_Args>()...)), _Expected>;
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool
+constexpr bool
     _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
         (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool
+constexpr bool
     _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&, _Rest...> =
         (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...> && ...);
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool
+constexpr bool
     _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
         (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool
+constexpr bool
     _Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args...>, const variant<_Types...>&&, _Rest...> =
         (_Variant_all_visit_results_same<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
 
@@ -1612,30 +1612,30 @@ constexpr _Variant_visit_result_t<_Callable, _As_variant<_Variants>...> visit(_C
 
 #if _HAS_CXX20
 template <class _Expected, class _Callable, class _ArgList, class... _Variants>
-inline constexpr bool _Variant_all_visit_results_convertible = false;
+constexpr bool _Variant_all_visit_results_convertible = false;
 
 template <class _Expected, class _Callable, class... _Args>
-inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>> =
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>> =
     _Invoke_convertible<decltype(_STD invoke(_STD declval<_Callable>(), _STD declval<_Args>()...)), _Expected>::value;
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool
+constexpr bool
     _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&, _Rest...> =
         (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types&>, _Rest...> && ...);
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
     const variant<_Types...>&, _Rest...> =
     (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types&>, _Rest...>
         && ...);
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool
+constexpr bool
     _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>, variant<_Types...>&&, _Rest...> =
         (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., _Types>, _Rest...> && ...);
 
 template <class _Expected, class _Callable, class... _Args, class... _Types, class... _Rest>
-inline constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
+constexpr bool _Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args...>,
     const variant<_Types...>&&, _Rest...> =
     (_Variant_all_visit_results_convertible<_Expected, _Callable, _Meta_list<_Args..., const _Types>, _Rest...> && ...);
 
diff --git a/stl/inc/vector b/stl/inc/vector
index 03a27349257..9cfe2530e2d 100644
--- a/stl/inc/vector
+++ b/stl/inc/vector
@@ -3600,10 +3600,10 @@ public:
 #endif // _HAS_CXX23
 
 template <class _Alloc, bool _RequiresMutable>
-_INLINE_VAR constexpr bool _Is_vb_iterator<_Vb_iterator<_Alloc>, _RequiresMutable> = true;
+constexpr bool _Is_vb_iterator<_Vb_iterator<_Alloc>, _RequiresMutable> = true;
 
 template <class _Alloc>
-_INLINE_VAR constexpr bool _Is_vb_iterator<_Vb_const_iterator<_Alloc>, false> = true;
+constexpr bool _Is_vb_iterator<_Vb_const_iterator<_Alloc>, false> = true;
 
 template <class _VbIt>
 _CONSTEXPR20 void _Fill_vbool(_VbIt _First, const _VbIt _Last, const bool _Val) noexcept {
diff --git a/stl/inc/xcharconv_ryu_tables.h b/stl/inc/xcharconv_ryu_tables.h
index a8d4e5a7b4e..a9aa5c3b3a3 100644
--- a/stl/inc/xcharconv_ryu_tables.h
+++ b/stl/inc/xcharconv_ryu_tables.h
@@ -62,7 +62,7 @@ _STD_BEGIN
 
 // A table of all two-digit numbers. This is used to speed up decimal digit
 // generation by copying pairs of digits into the final output.
-template <class _CharT> inline constexpr _CharT __DIGIT_TABLE[] = {_CharT{}};
+template <class _CharT> constexpr _CharT __DIGIT_TABLE[] = {_CharT{}};
 
 template <> inline constexpr char __DIGIT_TABLE<char>[200] = {
   '0','0','0','1','0','2','0','3','0','4','0','5','0','6','0','7','0','8','0','9',
diff --git a/stl/inc/xhash b/stl/inc/xhash
index 59c1c1e95e3..eab5314d472 100644
--- a/stl/inc/xhash
+++ b/stl/inc/xhash
@@ -116,7 +116,7 @@ struct _Uhash_choose_transparency<_Kty, _Hasher, _Keyeq,
 #endif // _HAS_CXX20
 
 template <class _Hasher, class _Kty>
-_INLINE_VAR constexpr bool _Nothrow_hash =
+constexpr bool _Nothrow_hash =
     noexcept(static_cast<size_t>(_STD declval<const _Hasher&>()(_STD declval<const _Kty&>())));
 
 template <class _Kty, class _Hasher, class _Keyeq>
diff --git a/stl/inc/xlocale b/stl/inc/xlocale
index 2d47e75cdce..f1f84c8bc75 100644
--- a/stl/inc/xlocale
+++ b/stl/inc/xlocale
@@ -653,7 +653,7 @@ protected:
 };
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_one_byte_char_like_v = _Is_any_of_v<remove_cv_t<_Ty>, signed char, unsigned char,
+constexpr bool _Is_one_byte_char_like_v = _Is_any_of_v<remove_cv_t<_Ty>, signed char, unsigned char,
 #ifdef __cpp_lib_byte
     byte,
 #endif // defined(__cpp_lib_byte)
@@ -663,7 +663,7 @@ _INLINE_VAR constexpr bool _Is_one_byte_char_like_v = _Is_any_of_v<remove_cv_t<_
     char>;
 
 template <class _Elem, class _Byte>
-_INLINE_VAR constexpr bool _Is_codecvt_do_always_noconv_v =
+constexpr bool _Is_codecvt_do_always_noconv_v =
     is_same_v<_Byte, _Elem> || (_Is_one_byte_char_like_v<_Byte> && _Is_one_byte_char_like_v<_Elem>);
 
 _EXPORT_STD extern "C++" template <class _Elem, class _Byte, class _Statype>
diff --git a/stl/inc/xmemory b/stl/inc/xmemory
index 499e9afb58a..57cce6685c4 100644
--- a/stl/inc/xmemory
+++ b/stl/inc/xmemory
@@ -68,7 +68,7 @@ struct _NODISCARD _Tidy_deallocate_guard { // class with destructor that calls _
 };
 
 template <class _Keycmp, class _Lhs, class _Rhs>
-_INLINE_VAR constexpr bool _Nothrow_compare = noexcept(
+constexpr bool _Nothrow_compare = noexcept(
     static_cast<bool>(_STD declval<const _Keycmp&>()(_STD declval<const _Lhs&>(), _STD declval<const _Rhs&>())));
 
 [[noreturn]] inline void _Throw_bad_array_new_length() {
@@ -90,7 +90,7 @@ _NODISCARD constexpr size_t _Get_size_of_n(const size_t _Count) {
 }
 
 template <class _Ty>
-_INLINE_VAR constexpr size_t _New_alignof = (_STD max)(alignof(_Ty), __STDCPP_DEFAULT_NEW_ALIGNMENT__);
+constexpr size_t _New_alignof = (_STD max)(alignof(_Ty), __STDCPP_DEFAULT_NEW_ALIGNMENT__);
 
 struct _Default_allocate_traits {
     __declspec(allocator) static
@@ -726,8 +726,8 @@ struct allocator_traits : conditional_t<_Is_default_allocator<_Alloc>::value, _D
 // _Choose_pocca_v returns whether an attempt to propagate allocators is necessary in copy assignment operations.
 // Note that even when false_type, callers should call _Pocca as we want to assign allocators even when equal.
 template <class _Alloc>
-_INLINE_VAR constexpr bool _Choose_pocca_v = allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value
-                                          && !allocator_traits<_Alloc>::is_always_equal::value;
+constexpr bool _Choose_pocca_v = allocator_traits<_Alloc>::propagate_on_container_copy_assignment::value
+                              && !allocator_traits<_Alloc>::is_always_equal::value;
 
 enum class _Pocma_values {
     _Equal_allocators, // usually allows contents to be stolen (e.g. with swap)
@@ -736,12 +736,11 @@ enum class _Pocma_values {
 };
 
 template <class _Alloc>
-_INLINE_VAR constexpr _Pocma_values _Choose_pocma_v =
-    allocator_traits<_Alloc>::is_always_equal::value
-        ? _Pocma_values::_Equal_allocators
-        : (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value
-                ? _Pocma_values::_Propagate_allocators
-                : _Pocma_values::_No_propagate_allocators);
+constexpr _Pocma_values _Choose_pocma_v = allocator_traits<_Alloc>::is_always_equal::value
+                                            ? _Pocma_values::_Equal_allocators
+                                            : (allocator_traits<_Alloc>::propagate_on_container_move_assignment::value
+                                                    ? _Pocma_values::_Propagate_allocators
+                                                    : _Pocma_values::_No_propagate_allocators);
 
 template <class _Alloc, class _Value_type>
 using _Rebind_alloc_t = typename allocator_traits<_Alloc>::template rebind_alloc<_Value_type>;
@@ -754,7 +753,7 @@ using _Maybe_rebind_alloc_t =
         _Rebind_alloc_t<_Alloc, _Value_type>>;
 
 template <class _Alloc> // tests if allocator has simple addressing
-_INLINE_VAR constexpr bool _Is_simple_alloc_v =
+constexpr bool _Is_simple_alloc_v =
     is_same_v<typename allocator_traits<_Alloc>::size_type, size_t>
     && is_same_v<typename allocator_traits<_Alloc>::difference_type, ptrdiff_t>
     && is_same_v<typename allocator_traits<_Alloc>::pointer, typename _Alloc::value_type*>
@@ -885,10 +884,10 @@ _NODISCARD inline const void* _Get_asan_aligned_after(const void* const _End) no
 }
 
 template <class _Container, class = void>
-_INLINE_VAR constexpr size_t _Container_allocation_minimum_asan_alignment = alignof(typename _Container::value_type);
+constexpr size_t _Container_allocation_minimum_asan_alignment = alignof(typename _Container::value_type);
 
 template <class _Container>
-_INLINE_VAR constexpr size_t _Container_allocation_minimum_asan_alignment<_Container,
+constexpr size_t _Container_allocation_minimum_asan_alignment<_Container,
     void_t<decltype(_Container::allocator_type::_Minimum_asan_allocation_alignment)>> =
     (_STD max)(
         alignof(typename _Container::value_type), _Container::allocator_type::_Minimum_asan_allocation_alignment);
@@ -1986,10 +1985,9 @@ void uninitialized_fill(const _NoThrowFwdIt _First, const _NoThrowFwdIt _Last, c
 }
 
 template <class _NoThrowFwdIt>
-_INLINE_VAR constexpr bool _Use_memset_value_construct_v =
-    conjunction_v<bool_constant<_Iterator_is_contiguous<_NoThrowFwdIt>>, is_scalar<_Iter_value_t<_NoThrowFwdIt>>,
-        negation<is_volatile<remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>>>,
-        negation<is_member_pointer<_Iter_value_t<_NoThrowFwdIt>>>>;
+constexpr bool _Use_memset_value_construct_v = conjunction_v<bool_constant<_Iterator_is_contiguous<_NoThrowFwdIt>>,
+    is_scalar<_Iter_value_t<_NoThrowFwdIt>>, negation<is_volatile<remove_reference_t<_Iter_ref_t<_NoThrowFwdIt>>>>,
+    negation<is_member_pointer<_Iter_value_t<_NoThrowFwdIt>>>>;
 
 template <class _Ptr>
 _Ptr _Zero_range(const _Ptr _First, const _Ptr _Last) { // fill [_First, _Last) with zeroes
@@ -2159,15 +2157,15 @@ _NODISCARD constexpr bool _Allocators_equal(const _Alloc& _Lhs, const _Alloc& _R
 
 #if _HAS_CXX23
 template <class _Ty, class = void>
-inline constexpr bool _Has_member_from_primary = false;
+constexpr bool _Has_member_from_primary = false;
 template <class _Ty>
-inline constexpr bool _Has_member_from_primary<_Ty, void_t<typename _Ty::_From_primary>> = true;
+constexpr bool _Has_member_from_primary<_Ty, void_t<typename _Ty::_From_primary>> = true;
 
 // Avoid using allocate_at_least when the allocator publicly derives from std::allocator:
 // "old" allocators might hide allocate and deallocate but fail to hide allocate_at_least.
 // Also avoid using allocate_at_least from std::allocator itself because it currently doesn't do anything useful.
 template <class _Alloc>
-inline constexpr bool _Should_allocate_at_least =
+constexpr bool _Should_allocate_at_least =
     !_Has_member_from_primary<_Alloc>
     && _Has_member_allocate_at_least<_Alloc, typename allocator_traits<_Alloc>::size_type>;
 #endif // _HAS_CXX23
@@ -2271,13 +2269,13 @@ template <class _Ty1, class _Ty2>
 void _Deduce_as_pair(const pair<_Ty1, _Ty2>&); // not defined
 
 template <class _Ty, class = void>
-_INLINE_VAR constexpr bool _Is_deducible_as_pair = false;
+constexpr bool _Is_deducible_as_pair = false;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_deducible_as_pair<_Ty, decltype(_STD _Deduce_as_pair(_STD declval<_Ty>()))> = true;
+constexpr bool _Is_deducible_as_pair<_Ty, decltype(_STD _Deduce_as_pair(_STD declval<_Ty>()))> = true;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_cv_pair = _Is_specialization_v<remove_cv_t<_Ty>, pair>;
+constexpr bool _Is_cv_pair = _Is_specialization_v<remove_cv_t<_Ty>, pair>;
 
 template <class _Ty>
 const _Ty& _Normally_bind(_Identity_t<const _Ty&>); // not defined
@@ -2289,10 +2287,10 @@ template <class _Ty, class _Uty>
 using _Normally_bound_ref = decltype(_STD _Normally_bind<_Ty>(_STD declval<_Uty>()));
 
 template <class _Ty, class _Uty, class = void>
-_INLINE_VAR constexpr bool _Is_normally_bindable = false;
+constexpr bool _Is_normally_bindable = false;
 
 template <class _Ty, class _Uty>
-_INLINE_VAR constexpr bool _Is_normally_bindable<_Ty, _Uty, void_t<_Normally_bound_ref<_Ty, _Uty>>> = true;
+constexpr bool _Is_normally_bindable<_Ty, _Uty, void_t<_Normally_bound_ref<_Ty, _Uty>>> = true;
 
 #if _HAS_CXX20
 _EXPORT_STD template <class _Ty, class _Alloc, class... _Types, enable_if_t<!_Is_cv_pair<_Ty>, int> = 0>
@@ -2577,10 +2575,10 @@ _EXPORT_STD inline void* align(size_t _Bound, size_t _Size, void*& _Ptr, size_t&
 }
 
 template <class _Ty, class = void>
-_INLINE_VAR constexpr bool _Is_transparent_v = false;
+constexpr bool _Is_transparent_v = false;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_transparent_v<_Ty, void_t<typename _Ty::is_transparent>> = true;
+constexpr bool _Is_transparent_v<_Ty, void_t<typename _Ty::is_transparent>> = true;
 
 template <class _Ty>
 struct _Is_transparent : bool_constant<_Is_transparent_v<_Ty>> {};
diff --git a/stl/inc/xstring b/stl/inc/xstring
index 3b8a62ba6b8..f410c9299de 100644
--- a/stl/inc/xstring
+++ b/stl/inc/xstring
@@ -886,7 +886,7 @@ constexpr size_t _Traits_rfind_not_ch(_In_reads_(_Hay_size) const _Traits_ptr_t<
 }
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_EcharT = _Is_any_of_v<_Ty, char, wchar_t,
+constexpr bool _Is_EcharT = _Is_any_of_v<_Ty, char, wchar_t,
 #ifdef __cpp_char8_t
     char8_t,
 #endif // defined(__cpp_char8_t)
@@ -1637,9 +1637,9 @@ basic_string_view(_Range&&) -> basic_string_view<_RANGES range_value_t<_Range>>;
 
 namespace ranges {
     template <class _Elem, class _Traits>
-    inline constexpr bool enable_view<basic_string_view<_Elem, _Traits>> = true;
+    constexpr bool enable_view<basic_string_view<_Elem, _Traits>> = true;
     template <class _Elem, class _Traits>
-    inline constexpr bool enable_borrowed_range<basic_string_view<_Elem, _Traits>> = true;
+    constexpr bool enable_borrowed_range<basic_string_view<_Elem, _Traits>> = true;
 } // namespace ranges
 #endif // _HAS_CXX20
 
@@ -2307,7 +2307,7 @@ public:
 
 // get _Ty's size after being EBCO'd
 template <class _Ty>
-_INLINE_VAR constexpr size_t _Size_after_ebco_v = is_empty_v<_Ty> ? 0 : sizeof(_Ty);
+constexpr size_t _Size_after_ebco_v = is_empty_v<_Ty> ? 0 : sizeof(_Ty);
 
 struct _String_constructor_concat_tag {
     // tag to select constructors used by basic_string's concatenation operators (operator+)
diff --git a/stl/inc/xtr1common b/stl/inc/xtr1common
index 0709e650366..02ea58bc094 100644
--- a/stl/inc/xtr1common
+++ b/stl/inc/xtr1common
@@ -70,15 +70,15 @@ using conditional_t = typename conditional<_Test, _Ty1, _Ty2>::type;
 
 #ifdef __clang__
 _EXPORT_STD template <class _Ty1, class _Ty2>
-_INLINE_VAR constexpr bool is_same_v = __is_same(_Ty1, _Ty2);
+constexpr bool is_same_v = __is_same(_Ty1, _Ty2);
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_same : bool_constant<__is_same(_Ty1, _Ty2)> {};
 #else // ^^^ Clang / not Clang vvv
 _EXPORT_STD template <class, class>
-_INLINE_VAR constexpr bool is_same_v = false; // determine whether arguments are the same type
+constexpr bool is_same_v = false; // determine whether arguments are the same type
 template <class _Ty>
-_INLINE_VAR constexpr bool is_same_v<_Ty, _Ty> = true;
+constexpr bool is_same_v<_Ty, _Ty> = true;
 
 _EXPORT_STD template <class _Ty1, class _Ty2>
 struct is_same : bool_constant<is_same_v<_Ty1, _Ty2>> {};
@@ -164,10 +164,10 @@ struct disjunction<_First, _Rest...> : _Disjunction<_First::value, _First, _Rest
 };
 
 _EXPORT_STD template <class... _Traits>
-_INLINE_VAR constexpr bool disjunction_v = disjunction<_Traits...>::value;
+constexpr bool disjunction_v = disjunction<_Traits...>::value;
 
 template <class _Ty, class... _Types>
-_INLINE_VAR constexpr bool _Is_any_of_v = // true if and only if _Ty is in _Types
+constexpr bool _Is_any_of_v = // true if and only if _Ty is in _Types
 #if _HAS_CXX17
     (is_same_v<_Ty, _Types> || ...);
 #else // ^^^ _HAS_CXX17 / !_HAS_CXX17 vvv
@@ -185,8 +185,7 @@ _EXPORT_STD _NODISCARD constexpr bool is_constant_evaluated() noexcept {
 #endif // _HAS_CXX20
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char,
-    wchar_t,
+constexpr bool is_integral_v = _Is_any_of_v<remove_cv_t<_Ty>, bool, char, signed char, unsigned char, wchar_t,
 #ifdef __cpp_char8_t
     char8_t,
 #endif // defined(__cpp_char8_t)
@@ -196,13 +195,13 @@ _EXPORT_STD template <class _Ty>
 struct is_integral : bool_constant<is_integral_v<_Ty>> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_floating_point_v = _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;
+constexpr bool is_floating_point_v = _Is_any_of_v<remove_cv_t<_Ty>, float, double, long double>;
 
 _EXPORT_STD template <class _Ty>
 struct is_floating_point : bool_constant<is_floating_point_v<_Ty>> {};
 
 _EXPORT_STD template <class _Ty>
-_INLINE_VAR constexpr bool is_arithmetic_v = // determine whether _Ty is an arithmetic type
+constexpr bool is_arithmetic_v = // determine whether _Ty is an arithmetic type
     is_integral_v<_Ty> || is_floating_point_v<_Ty>;
 
 _EXPORT_STD template <class _Ty>
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 6e960212172..119ff45f23d 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -730,10 +730,10 @@ struct _Unused_parameter { // generic unused parameter struct
 };
 
 template <class _Ty, class = void> // checks whether a container/view is a non-customized specialization
-_INLINE_VAR constexpr bool _Has_unchecked_begin_end = false;
+constexpr bool _Has_unchecked_begin_end = false;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Has_unchecked_begin_end<_Ty,
+constexpr bool _Has_unchecked_begin_end<_Ty,
     void_t<decltype(_STD declval<_Ty&>()._Unchecked_begin()), decltype(_STD declval<_Ty&>()._Unchecked_end())>> = true;
 
 template <class _Ty>
@@ -1211,49 +1211,49 @@ template <class _Iter>
 using _Iter_cat_t = typename iterator_traits<_Iter>::iterator_category;
 
 template <class _Ty, class = void>
-_INLINE_VAR constexpr bool _Is_iterator_v = false;
+constexpr bool _Is_iterator_v = false;
 
 template <class _Ty>
-_INLINE_VAR constexpr bool _Is_iterator_v<_Ty, void_t<_Iter_cat_t<_Ty>>> = true;
+constexpr bool _Is_iterator_v<_Ty, void_t<_Iter_cat_t<_Ty>>> = true;
 
 template <class _Ty>
 struct _Is_iterator : bool_constant<_Is_iterator_v<_Ty>> {};
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_cpp17_input_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, input_iterator_tag>;
+constexpr bool _Is_cpp17_input_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, input_iterator_tag>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_ranges_input_iter_v =
+constexpr bool _Is_ranges_input_iter_v =
 #if _HAS_CXX20
     (input_iterator<_Iter> && sentinel_for<_Iter, _Iter>) ||
 #endif
     _Is_cpp17_input_iter_v<_Iter>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_cpp17_fwd_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, forward_iterator_tag>;
+constexpr bool _Is_cpp17_fwd_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, forward_iterator_tag>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_ranges_fwd_iter_v =
+constexpr bool _Is_ranges_fwd_iter_v =
 #if _HAS_CXX20
     forward_iterator<_Iter> ||
 #endif
     _Is_cpp17_fwd_iter_v<_Iter>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_cpp17_bidi_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, bidirectional_iterator_tag>;
+constexpr bool _Is_cpp17_bidi_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, bidirectional_iterator_tag>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_ranges_bidi_iter_v =
+constexpr bool _Is_ranges_bidi_iter_v =
 #if _HAS_CXX20
     bidirectional_iterator<_Iter> ||
 #endif
     _Is_cpp17_bidi_iter_v<_Iter>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_cpp17_random_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, random_access_iterator_tag>;
+constexpr bool _Is_cpp17_random_iter_v = is_convertible_v<_Iter_cat_t<_Iter>, random_access_iterator_tag>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Is_ranges_random_iter_v =
+constexpr bool _Is_ranges_random_iter_v =
 #if _HAS_CXX20
     random_access_iterator<_Iter> ||
 #endif
@@ -1279,17 +1279,17 @@ constexpr void _Verify_range(const _Ty* const _First, const _Ty* const _Last) no
 #endif // _ITERATOR_DEBUG_LEVEL != 0
 
 template <class _Iter, class = void>
-_INLINE_VAR constexpr bool _Allow_inheriting_unwrap_v = true;
+constexpr bool _Allow_inheriting_unwrap_v = true;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Allow_inheriting_unwrap_v<_Iter, void_t<typename _Iter::_Prevent_inheriting_unwrap>> =
+constexpr bool _Allow_inheriting_unwrap_v<_Iter, void_t<typename _Iter::_Prevent_inheriting_unwrap>> =
     is_same_v<_Iter, typename _Iter::_Prevent_inheriting_unwrap>;
 
 template <class _Iter, class _Sentinel = _Iter, class = void>
-_INLINE_VAR constexpr bool _Range_verifiable_v = false;
+constexpr bool _Range_verifiable_v = false;
 
 template <class _Iter, class _Sentinel>
-_INLINE_VAR constexpr bool _Range_verifiable_v<_Iter, _Sentinel,
+constexpr bool _Range_verifiable_v<_Iter, _Sentinel,
     void_t<decltype(_Verify_range(_STD declval<const _Iter&>(), _STD declval<const _Sentinel&>()))>> =
     _Allow_inheriting_unwrap_v<_Iter>;
 
@@ -1306,17 +1306,17 @@ constexpr void _Adl_verify_range(const _Iter& _First, const _Sentinel& _Last) {
 }
 
 template <class _Iter, class = void>
-_INLINE_VAR constexpr bool _Unwrappable_v = false;
+constexpr bool _Unwrappable_v = false;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Unwrappable_v<_Iter,
+constexpr bool _Unwrappable_v<_Iter,
     void_t<decltype(_STD declval<_Remove_cvref_t<_Iter>&>()._Seek_to(_STD declval<_Iter>()._Unwrapped()))>> =
     _Allow_inheriting_unwrap_v<_Remove_cvref_t<_Iter>>;
 
 template <class _Iter, class = void>
-_INLINE_VAR constexpr bool _Has_nothrow_unwrapped = false;
+constexpr bool _Has_nothrow_unwrapped = false;
 template <class _Iter>
-_INLINE_VAR constexpr bool _Has_nothrow_unwrapped<_Iter, void_t<decltype(_STD declval<_Iter>()._Unwrapped())>> =
+constexpr bool _Has_nothrow_unwrapped<_Iter, void_t<decltype(_STD declval<_Iter>()._Unwrapped())>> =
     noexcept(_STD declval<_Iter>()._Unwrapped());
 
 template <class _Iter>
@@ -1336,15 +1336,14 @@ template <class _Iter>
 using _Unwrapped_t = _Remove_cvref_t<decltype(_STD _Get_unwrapped(_STD declval<_Iter>()))>;
 
 template <class _Iter, class = bool>
-_INLINE_VAR constexpr bool _Do_unwrap_when_unverified_v = false;
+constexpr bool _Do_unwrap_when_unverified_v = false;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool
-    _Do_unwrap_when_unverified_v<_Iter, decltype(static_cast<bool>(_Iter::_Unwrap_when_unverified))> =
-        static_cast<bool>(_Iter::_Unwrap_when_unverified);
+constexpr bool _Do_unwrap_when_unverified_v<_Iter, decltype(static_cast<bool>(_Iter::_Unwrap_when_unverified))> =
+    static_cast<bool>(_Iter::_Unwrap_when_unverified);
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Unwrappable_for_unverified_v =
+constexpr bool _Unwrappable_for_unverified_v =
     _Unwrappable_v<_Iter> && _Do_unwrap_when_unverified_v<_Remove_cvref_t<_Iter>>;
 
 template <class _Iter>
@@ -1369,22 +1368,21 @@ struct _Distance_unknown {
 };
 
 template <class _Diff>
-_INLINE_VAR constexpr _Diff _Max_possible_v{static_cast<_Make_unsigned_like_t<_Diff>>(-1) >> 1};
+constexpr _Diff _Max_possible_v{static_cast<_Make_unsigned_like_t<_Diff>>(-1) >> 1};
 
 template <class _Diff>
-_INLINE_VAR constexpr _Diff _Min_possible_v{-_Max_possible_v<_Diff> - 1};
+constexpr _Diff _Min_possible_v{-_Max_possible_v<_Diff> - 1};
 
 template <class _Iter, class = void>
-_INLINE_VAR constexpr bool _Offset_verifiable_v = false;
+constexpr bool _Offset_verifiable_v = false;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool
+constexpr bool
     _Offset_verifiable_v<_Iter, void_t<decltype(_STD declval<const _Iter&>()._Verify_offset(_Iter_diff_t<_Iter>{}))>> =
         true;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Unwrappable_for_offset_v =
-    _Unwrappable_v<_Iter> && _Offset_verifiable_v<_Remove_cvref_t<_Iter>>;
+constexpr bool _Unwrappable_for_offset_v = _Unwrappable_v<_Iter> && _Offset_verifiable_v<_Remove_cvref_t<_Iter>>;
 
 template <class _Iter, class _Diff>
 _NODISCARD constexpr decltype(auto) _Get_unwrapped_n(_Iter&& _It, const _Diff _Off) {
@@ -1413,10 +1411,10 @@ _NODISCARD constexpr decltype(auto) _Get_unwrapped_n(_Iter&& _It, const _Diff _O
 }
 
 template <class _Iter, class _UIter, class = void>
-_INLINE_VAR constexpr bool _Wrapped_seekable_v = false;
+constexpr bool _Wrapped_seekable_v = false;
 
 template <class _Iter, class _UIter>
-_INLINE_VAR constexpr bool
+constexpr bool
     _Wrapped_seekable_v<_Iter, _UIter, void_t<decltype(_STD declval<_Iter&>()._Seek_to(_STD declval<_UIter>()))>> =
         true;
 
@@ -1469,7 +1467,7 @@ _EXPORT_STD template <class _Ty>
 struct is_execution_policy : false_type {};
 
 _EXPORT_STD template <class _Ty>
-inline constexpr bool is_execution_policy_v = is_execution_policy<_Ty>::value;
+constexpr bool is_execution_policy_v = is_execution_policy<_Ty>::value;
 
 // Note: The noexcept specifiers on all parallel algorithm overloads enforce termination as per
 // N4950 [execpol.seq]/2, [execpol.par]/2, [execpol.parunseq]/2, and [execpol.unseq]/2
@@ -1631,10 +1629,10 @@ _NODISCARD _CONSTEXPR17 _BidIt prev(
 }
 
 template <class _Iter, class _Pointer, bool = is_pointer_v<_Remove_cvref_t<_Iter>>>
-_INLINE_VAR constexpr bool _Has_nothrow_operator_arrow = _Is_nothrow_convertible_v<_Iter, _Pointer>;
+constexpr bool _Has_nothrow_operator_arrow = _Is_nothrow_convertible_v<_Iter, _Pointer>;
 
 template <class _Iter, class _Pointer>
-_INLINE_VAR constexpr bool _Has_nothrow_operator_arrow<_Iter, _Pointer, false> =
+constexpr bool _Has_nothrow_operator_arrow<_Iter, _Pointer, false> =
     noexcept(_STD _Fake_copy_init<_Pointer>(_STD declval<_Iter>().operator->()));
 
 _EXPORT_STD template <class _BidIt>
@@ -1934,7 +1932,7 @@ _NODISCARD _CONSTEXPR17 reverse_iterator<_BidIt> make_reverse_iterator(_BidIt _I
 #if _HAS_CXX20
 template <class _BidIt1, class _BidIt2>
     requires (!sized_sentinel_for<_BidIt1, _BidIt2>)
-inline constexpr bool disable_sized_sentinel_for<reverse_iterator<_BidIt1>, reverse_iterator<_BidIt2>> = true;
+constexpr bool disable_sized_sentinel_for<reverse_iterator<_BidIt1>, reverse_iterator<_BidIt2>> = true;
 #endif // _HAS_CXX20
 
 _EXPORT_STD template <class _Container>
@@ -2465,14 +2463,14 @@ _NODISCARD constexpr const_sentinel<_Sent> make_const_sentinel(_Sent _Se) noexce
 
 namespace ranges {
     template <class>
-    inline constexpr bool _Has_complete_elements = false;
+    constexpr bool _Has_complete_elements = false;
 
     template <class _Ty>
         requires requires(_Ty& __t) { sizeof(__t[0]); }
-    inline constexpr bool _Has_complete_elements<_Ty> = true;
+    constexpr bool _Has_complete_elements<_Ty> = true;
 
     _EXPORT_STD template <class>
-    inline constexpr bool enable_borrowed_range = false;
+    constexpr bool enable_borrowed_range = false;
 
     template <class _Rng>
     concept _Should_range_access = is_lvalue_reference_v<_Rng> || enable_borrowed_range<remove_cvref_t<_Rng>>;
@@ -3106,7 +3104,7 @@ namespace ranges {
     }
 
     _EXPORT_STD template <class>
-    inline constexpr bool disable_sized_range = false;
+    constexpr bool disable_sized_range = false;
 
     namespace _Size {
 #if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1681199
@@ -3349,7 +3347,7 @@ namespace ranges {
     class view_interface;
 
     _EXPORT_STD template <class _Ty>
-    inline constexpr bool enable_view =
+    constexpr bool enable_view =
         derived_from<_Ty, view_base> || _Strictly_derived_from_specialization_of<_Ty, view_interface>;
 
     _EXPORT_STD template <class _Ty>
@@ -4065,7 +4063,7 @@ namespace ranges {
         -> subrange<iterator_t<_Rng>, sentinel_t<_Rng>, subrange_kind::sized>;
 
     template <class _It, class _Se, subrange_kind _Ki>
-    inline constexpr bool enable_borrowed_range<subrange<_It, _Se, _Ki>> = true;
+    constexpr bool enable_borrowed_range<subrange<_It, _Se, _Ki>> = true;
 
     _EXPORT_STD template <size_t _Idx, class _It, class _Se, subrange_kind _Ki>
         requires ((_Idx == 0 && copyable<_It>) || _Idx == 1)
@@ -4473,7 +4471,7 @@ _NODISCARD _CONSTEXPR17 move_iterator<_Iter> make_move_iterator(_Iter _It) noexc
 #if _HAS_CXX20
 template <class _Iter1, class _Iter2>
     requires (!sized_sentinel_for<_Iter1, _Iter2>)
-inline constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;
+constexpr bool disable_sized_sentinel_for<move_iterator<_Iter1>, move_iterator<_Iter2>> = true;
 
 _EXPORT_STD struct unreachable_sentinel_t;
 namespace _Unreachable_sentinel_detail {
@@ -4495,7 +4493,7 @@ _EXPORT_STD inline constexpr unreachable_sentinel_t unreachable_sentinel{};
 #if _HAS_CXX20
 // When concepts are available, we can detect arbitrary contiguous iterators.
 template <class _Iter>
-inline constexpr bool _Iterator_is_contiguous = contiguous_iterator<_Iter>;
+constexpr bool _Iterator_is_contiguous = contiguous_iterator<_Iter>;
 
 template <class _Iter>
 _NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
@@ -4505,7 +4503,7 @@ _NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
 #else // ^^^ _HAS_CXX20 / !_HAS_CXX20 vvv
 // When concepts aren't available, we can detect pointers. (Iterators should be unwrapped before using this.)
 template <class _Iter>
-_INLINE_VAR constexpr bool _Iterator_is_contiguous = is_pointer_v<_Iter>;
+constexpr bool _Iterator_is_contiguous = is_pointer_v<_Iter>;
 
 template <class _Iter>
 _NODISCARD constexpr auto _To_address(const _Iter& _Val) noexcept {
@@ -4522,19 +4520,18 @@ _NODISCARD constexpr auto _To_address(const move_iterator<_Iter>& _Val) noexcept
 // _Iterators_are_contiguous<_Iter1, _Iter2> reports whether both iterators are known to be contiguous.
 
 template <class _Iter1, class _Iter2>
-_INLINE_VAR constexpr bool _Iterators_are_contiguous =
-    _Iterator_is_contiguous<_Iter1> && _Iterator_is_contiguous<_Iter2>;
+constexpr bool _Iterators_are_contiguous = _Iterator_is_contiguous<_Iter1> && _Iterator_is_contiguous<_Iter2>;
 
 template <class _Iter>
-_INLINE_VAR constexpr bool _Iterator_is_volatile = is_volatile_v<remove_reference_t<_Iter_ref_t<_Iter>>>;
+constexpr bool _Iterator_is_volatile = is_volatile_v<remove_reference_t<_Iter_ref_t<_Iter>>>;
 
 template <class _Source, class _Dest>
-_INLINE_VAR constexpr bool _Is_pointer_address_convertible = is_void_v<_Source>
-                                                          || is_void_v<_Dest>
-                                                          // NOTE: is_same_v is required for function pointers to work
-                                                          || is_same_v<remove_cv_t<_Source>, remove_cv_t<_Dest>>
+constexpr bool _Is_pointer_address_convertible = is_void_v<_Source>
+                                              || is_void_v<_Dest>
+                                              // NOTE: is_same_v is required for function pointers to work
+                                              || is_same_v<remove_cv_t<_Source>, remove_cv_t<_Dest>>
 #ifdef __cpp_lib_is_pointer_interconvertible
-                                                          || is_pointer_interconvertible_base_of_v<_Dest, _Source>
+                                              || is_pointer_interconvertible_base_of_v<_Dest, _Source>
 #endif // defined(__cpp_lib_is_pointer_interconvertible)
     ;
 
@@ -4657,7 +4654,7 @@ _OutCtgIt _Copy_memmove_n(_CtgIt _First, const size_t _Count, _OutCtgIt _Dest) {
 }
 
 template <class _It, bool _RequiresMutable = false>
-_INLINE_VAR constexpr bool _Is_vb_iterator = false;
+constexpr bool _Is_vb_iterator = false;
 
 template <class _VbIt, class _OutIt>
 _CONSTEXPR20 _OutIt _Copy_vbool(_VbIt _First, _VbIt _Last, _OutIt _Dest);
@@ -5117,20 +5114,20 @@ struct _Is_character_or_byte_or_bool<byte> : true_type {};
 // _Fill_memset_is_safe determines if _FwdIt and _Ty are eligible for memset optimization in fill.
 // Need to explicitly test for volatile because _Unwrap_enum_t discards qualifiers.
 template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
-_INLINE_VAR constexpr bool _Fill_memset_is_safe = conjunction_v<is_scalar<_Ty>,
+constexpr bool _Fill_memset_is_safe = conjunction_v<is_scalar<_Ty>,
     _Is_character_or_byte_or_bool<_Unwrap_enum_t<remove_reference_t<_Iter_ref_t<_FwdIt>>>>,
     negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;
 
 template <class _FwdIt, class _Ty>
-_INLINE_VAR constexpr bool _Fill_memset_is_safe<_FwdIt, _Ty, false> = false;
+constexpr bool _Fill_memset_is_safe<_FwdIt, _Ty, false> = false;
 
 template <class _FwdIt, class _Ty, bool = _Iterator_is_contiguous<_FwdIt>>
-_INLINE_VAR constexpr bool _Fill_zero_memset_is_safe =
+constexpr bool _Fill_zero_memset_is_safe =
     conjunction_v<is_scalar<_Ty>, is_scalar<_Iter_value_t<_FwdIt>>, negation<is_member_pointer<_Iter_value_t<_FwdIt>>>,
         negation<is_volatile<remove_reference_t<_Iter_ref_t<_FwdIt>>>>, is_assignable<_Iter_ref_t<_FwdIt>, const _Ty&>>;
 
 template <class _FwdIt, class _Ty>
-_INLINE_VAR constexpr bool _Fill_zero_memset_is_safe<_FwdIt, _Ty, false> = false;
+constexpr bool _Fill_zero_memset_is_safe<_FwdIt, _Ty, false> = false;
 
 template <class _CtgIt, class _Ty>
 void _Fill_memset(_CtgIt _Dest, const _Ty _Val, const size_t _Count) {
@@ -5283,15 +5280,15 @@ namespace ranges {
 #endif // _HAS_CXX20
 
 template <class _Ty1, class _Ty2, class = void>
-_INLINE_VAR constexpr bool _Can_compare_with_operator_equal = false;
+constexpr bool _Can_compare_with_operator_equal = false;
 
 template <class _Ty1, class _Ty2>
-_INLINE_VAR constexpr bool
+constexpr bool
     _Can_compare_with_operator_equal<_Ty1, _Ty2, void_t<decltype(_STD declval<_Ty1&>() == _STD declval<_Ty2&>())>> =
         true;
 
 template <class _Ty1, class _Ty2>
-_INLINE_VAR constexpr bool _Is_pointer_address_comparable =
+constexpr bool _Is_pointer_address_comparable =
     _Can_compare_with_operator_equal<_Ty1*, _Ty2*>
     && (_Is_pointer_address_convertible<_Ty1, _Ty2> || _Is_pointer_address_convertible<_Ty2, _Ty1>);
 
@@ -5306,7 +5303,7 @@ _INLINE_VAR constexpr bool _Is_pointer_address_comparable =
 #pragma warning(disable : 4806) // no value of type 'bool' promoted to type 'char' can equal the given constant
 template <class _Elem1, class _Elem2,
     bool = sizeof(_Elem1) == sizeof(_Elem2) && is_integral_v<_Elem1> && is_integral_v<_Elem2>>
-_INLINE_VAR constexpr bool _Can_memcmp_elements =
+constexpr bool _Can_memcmp_elements =
     is_same_v<_Elem1, bool> || is_same_v<_Elem2, bool> || static_cast<_Elem1>(-1) == static_cast<_Elem2>(-1);
 #pragma warning(pop)
 
@@ -5321,46 +5318,44 @@ inline constexpr bool _Can_memcmp_elements<byte, byte, false> = true;
 // Pointer elements are eligible for memcmp when they point to the same type, ignoring cv-qualification.
 // This handles pointers to object types, pointers to void, and pointers to function types.
 template <class _Ty1, class _Ty2>
-_INLINE_VAR constexpr bool _Can_memcmp_elements<_Ty1*, _Ty2*, false> = _Is_pointer_address_comparable<_Ty1, _Ty2>;
+constexpr bool _Can_memcmp_elements<_Ty1*, _Ty2*, false> = _Is_pointer_address_comparable<_Ty1, _Ty2>;
 
 template <class _Elem1, class _Elem2>
-_INLINE_VAR constexpr bool _Can_memcmp_elements<_Elem1, _Elem2, false> = false;
+constexpr bool _Can_memcmp_elements<_Elem1, _Elem2, false> = false;
 
 // _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _Pr> reports whether the memcmp optimization is applicable,
 // given contiguously stored elements. (This avoids having to repeat the metaprogramming that finds the element types.)
 // _Elem1 and _Elem2 aren't top-level const here.
 template <class _Elem1, class _Elem2, class _Pr>
-_INLINE_VAR constexpr bool _Can_memcmp_elements_with_pred = false;
+constexpr bool _Can_memcmp_elements_with_pred = false;
 
 // With equal_to<_Elem3> we need to make sure that both _Elem1 and _Elem2 are convertible to _Elem3 without changing
 // object representation (we use _Iter_copy_cat for this task) and _Elem3 can be safely memcmp'ed with itself
 template <class _Elem1, class _Elem2, class _Elem3>
-_INLINE_VAR constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<_Elem3>> =
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<_Elem3>> =
     _Iter_copy_cat<_Elem1*, _Elem3*>::_Bitcopy_constructible && _Iter_copy_cat<_Elem2*, _Elem3*>::_Bitcopy_constructible
     && _Can_memcmp_elements<remove_cv_t<_Elem3>, remove_cv_t<_Elem3>>;
 
 // equal_to<> is transparent.
 template <class _Elem1, class _Elem2>
-_INLINE_VAR constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<>> =
-    _Can_memcmp_elements<_Elem1, _Elem2>;
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, equal_to<>> = _Can_memcmp_elements<_Elem1, _Elem2>;
 
 #if _HAS_CXX20
 // ranges::equal_to is also transparent.
 template <class _Elem1, class _Elem2>
-_INLINE_VAR constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _RANGES equal_to> =
-    _Can_memcmp_elements<_Elem1, _Elem2>;
+constexpr bool _Can_memcmp_elements_with_pred<_Elem1, _Elem2, _RANGES equal_to> = _Can_memcmp_elements<_Elem1, _Elem2>;
 #endif // _HAS_CXX20
 
 // _Equal_memcmp_is_safe<_Iter1, _Iter2, _Pr> reports whether we can activate the memcmp optimization
 // for arbitrary iterators and predicates.
 // It ignores top-level constness on the iterators and on the elements.
 template <class _Iter1, class _Iter2, class _Pr>
-_INLINE_VAR constexpr bool _Equal_memcmp_is_safe_helper =
+constexpr bool _Equal_memcmp_is_safe_helper =
     _Iterators_are_contiguous<_Iter1, _Iter2> && !_Iterator_is_volatile<_Iter1> && !_Iterator_is_volatile<_Iter2>
     && _Can_memcmp_elements_with_pred<_Iter_value_t<_Iter1>, _Iter_value_t<_Iter2>, _Pr>;
 
 template <class _Iter1, class _Iter2, class _Pr>
-_INLINE_VAR constexpr bool _Equal_memcmp_is_safe =
+constexpr bool _Equal_memcmp_is_safe =
     _Equal_memcmp_is_safe_helper<remove_const_t<_Iter1>, remove_const_t<_Iter2>, _Pr>;
 
 template <class _CtgIt1, class _CtgIt2>
@@ -5634,7 +5629,7 @@ namespace ranges {
 #endif // _HAS_CXX20
 
 template <class _Elem1, class _Elem2>
-_INLINE_VAR constexpr bool _Lex_compare_memcmp_classify_elements = conjunction_v<_Is_character_or_bool<_Elem1>,
+constexpr bool _Lex_compare_memcmp_classify_elements = conjunction_v<_Is_character_or_bool<_Elem1>,
     _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>, is_unsigned<_Elem2>>;
 
 #ifdef __cpp_lib_byte
@@ -6753,7 +6748,7 @@ namespace ranges {
 #endif // _HAS_CXX20
 
 template <class _Iter, class _Pr, class _Elem = _Iter_value_t<_Iter>>
-_INLINE_VAR constexpr bool _Is_min_max_optimization_safe = // Activate the vector algorithms for min_/max_element?
+constexpr bool _Is_min_max_optimization_safe = // Activate the vector algorithms for min_/max_element?
     _Iterator_is_contiguous<_Iter> // The iterator must be contiguous so we can get raw pointers.
     && !_Iterator_is_volatile<_Iter> // The iterator must not be volatile.
     && conjunction_v<disjunction<
diff --git a/tests/std/include/is_permissive.hpp b/tests/std/include/is_permissive.hpp
index a007ec5da78..e602b6cad6f 100644
--- a/tests/std/include/is_permissive.hpp
+++ b/tests/std/include/is_permissive.hpp
@@ -26,6 +26,6 @@ namespace detail {
 } // namespace detail
 
 template <class T>
-_INLINE_VAR constexpr bool is_permissive_v = detail::PermissiveTest<T>::test();
+constexpr bool is_permissive_v = detail::PermissiveTest<T>::test();
 
 _INLINE_VAR constexpr bool is_permissive = is_permissive_v<int>;
diff --git a/tests/std/include/range_algorithm_support.hpp b/tests/std/include/range_algorithm_support.hpp
index 3e69d85de3a..4d33f1df3d5 100644
--- a/tests/std/include/range_algorithm_support.hpp
+++ b/tests/std/include/range_algorithm_support.hpp
@@ -19,10 +19,10 @@
 namespace ranges = std::ranges;
 
 template <class>
-inline constexpr bool always_false = false;
+constexpr bool always_false = false;
 
 template <class T>
-inline constexpr T* nullptr_to = nullptr;
+constexpr T* nullptr_to = nullptr;
 
 template <bool>
 struct borrowed { // borrowed<true> is a borrowed_range; borrowed<false> is not
@@ -939,7 +939,7 @@ namespace test {
 
 template <class Category, class Element, test::Sized IsSized, test::CanDifference Diff, test::Common IsCommon,
     test::CanCompare Eq, test::ProxyRef Proxy, test::Copyability Copy>
-inline constexpr bool std::ranges::enable_view<
+constexpr bool std::ranges::enable_view<
     test::range<Category, Element, IsSized, Diff, IsCommon, Eq, Proxy, test::CanView::yes, Copy>> = true;
 
 template <class T>
@@ -953,7 +953,7 @@ template <ranges::contiguous_range R>
 basic_borrowed_range(R&) -> basic_borrowed_range<std::remove_reference_t<ranges::range_reference_t<R>>>;
 
 template <class T>
-inline constexpr bool ranges::enable_borrowed_range<::basic_borrowed_range<T>> = true;
+constexpr bool ranges::enable_borrowed_range<::basic_borrowed_range<T>> = true;
 
 template <int>
 struct unique_tag {};
diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index de86eee8936..b9d4a0acf84 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -62,13 +62,13 @@ concept NotImplicitlyConstructibleFrom = std::constructible_from<T, Args...> &&
 
 namespace detail {
     template <class T>
-    inline constexpr bool is_extents_v = false;
+    constexpr bool is_extents_v = false;
 
     template <class T, size_t... E>
-    inline constexpr bool is_extents_v<std::extents<T, E...>> = true;
+    constexpr bool is_extents_v<std::extents<T, E...>> = true;
 
     template <class Layout, class Mapping>
-    inline constexpr bool is_mapping_of_v =
+    constexpr bool is_mapping_of_v =
         std::is_same_v<typename Layout::template mapping<typename Mapping::extents_type>, Mapping>;
 
     template <class M>
diff --git a/tests/std/tests/GH_000140_adl_proof_views/test.compile.pass.cpp b/tests/std/tests/GH_000140_adl_proof_views/test.compile.pass.cpp
index 624b6e42d37..55fb8c35b51 100644
--- a/tests/std/tests/GH_000140_adl_proof_views/test.compile.pass.cpp
+++ b/tests/std/tests/GH_000140_adl_proof_views/test.compile.pass.cpp
@@ -177,10 +177,10 @@ struct tagged_ints_view {
 };
 
 template <class Tag>
-inline constexpr bool ranges::enable_view<tagged_ints_view<Tag>> = true;
+constexpr bool ranges::enable_view<tagged_ints_view<Tag>> = true;
 
 template <class Tag>
-inline constexpr bool ranges::enable_borrowed_range<tagged_ints_view<Tag>> = true;
+constexpr bool ranges::enable_borrowed_range<tagged_ints_view<Tag>> = true;
 
 struct validating_view_to_join_for_verification {
     constexpr const tagged_ints_view<holder<incomplete>>* begin() const noexcept {
diff --git a/tests/std/tests/GH_000935_complex_numerical_accuracy/floating_point_utils.hpp b/tests/std/tests/GH_000935_complex_numerical_accuracy/floating_point_utils.hpp
index 153260d5bf1..842b654418e 100644
--- a/tests/std/tests/GH_000935_complex_numerical_accuracy/floating_point_utils.hpp
+++ b/tests/std/tests/GH_000935_complex_numerical_accuracy/floating_point_utils.hpp
@@ -15,25 +15,25 @@ namespace fputil {
     using float_bits_t = typename _STD _Floating_type_traits<T>::_Uint_type;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> sign_mask_v = _STD _Floating_type_traits<T>::_Shifted_sign_mask;
+    constexpr float_bits_t<T> sign_mask_v = _STD _Floating_type_traits<T>::_Shifted_sign_mask;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> magnitude_mask_v = ~sign_mask_v<T>;
+    constexpr float_bits_t<T> magnitude_mask_v = ~sign_mask_v<T>;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> exponent_mask_v = _STD _Floating_type_traits<T>::_Shifted_exponent_mask;
+    constexpr float_bits_t<T> exponent_mask_v = _STD _Floating_type_traits<T>::_Shifted_exponent_mask;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> significand_mask_v = magnitude_mask_v<T> & ~exponent_mask_v<T>;
+    constexpr float_bits_t<T> significand_mask_v = magnitude_mask_v<T> & ~exponent_mask_v<T>;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> norm_min_bits_v = significand_mask_v<T> + 1U;
+    constexpr float_bits_t<T> norm_min_bits_v = significand_mask_v<T> + 1U;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> norm_max_bits_v = exponent_mask_v<T> - 1U;
+    constexpr float_bits_t<T> norm_max_bits_v = exponent_mask_v<T> - 1U;
 
     template <typename T>
-    _INLINE_VAR constexpr float_bits_t<T> infinity_bits_v = exponent_mask_v<T>;
+    constexpr float_bits_t<T> infinity_bits_v = exponent_mask_v<T>;
 
     // not affected by abrupt underflow
     template <typename T, std::enable_if_t<std::is_floating_point_v<T>, int> = 0>
diff --git a/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp b/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp
index 0ca11479715..1e2027b3147 100644
--- a/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp
+++ b/tests/std/tests/LWG3528_make_from_tuple_impl/test.compile.pass.cpp
@@ -27,11 +27,11 @@ enum class D {
 };
 
 template <class T, class Tuple, class = void>
-inline constexpr bool has_make_from_tuple = false;
+constexpr bool has_make_from_tuple = false;
 
 template <class T, class Tuple>
-inline constexpr bool
-    has_make_from_tuple<T, Tuple, std::void_t<decltype(std::make_from_tuple<T>(std::declval<Tuple>()))>> = true;
+constexpr bool has_make_from_tuple<T, Tuple, std::void_t<decltype(std::make_from_tuple<T>(std::declval<Tuple>()))>> =
+    true;
 
 // Test std::make_from_tuple.
 
diff --git a/tests/std/tests/P0088R3_variant/test.cpp b/tests/std/tests/P0088R3_variant/test.cpp
index 838fc0f574a..018b96d8750 100644
--- a/tests/std/tests/P0088R3_variant/test.cpp
+++ b/tests/std/tests/P0088R3_variant/test.cpp
@@ -7102,7 +7102,7 @@ namespace msvc {
         };
 
         template <class... Ts>
-        inline constexpr bool check_size = sizeof(std::variant<Ts...>) == sizeof(fake_variant<Ts...>);
+        constexpr bool check_size = sizeof(std::variant<Ts...>) == sizeof(fake_variant<Ts...>);
 
         template <int>
         struct empty {};
@@ -7757,9 +7757,9 @@ namespace msvc {
     } // namespace visit_pointer_to_member
 
     template <class, class = void>
-    inline constexpr bool has_type = false;
+    constexpr bool has_type = false;
     template <class T>
-    inline constexpr bool has_type<T, std::void_t<typename T::type>> = true;
+    constexpr bool has_type<T, std::void_t<typename T::type>> = true;
 
     // Verify that `_Meta_at_<_Meta_list<>, size_t(-1)>` has no member named `type`, and that instantiating it doesn't
     // consume the entire compiler heap.
diff --git a/tests/std/tests/P0122R7_span/test.cpp b/tests/std/tests/P0122R7_span/test.cpp
index e6b2bd8acdf..276e1b3d455 100644
--- a/tests/std/tests/P0122R7_span/test.cpp
+++ b/tests/std/tests/P0122R7_span/test.cpp
@@ -142,7 +142,7 @@ struct BasicRange {
 
 namespace std::ranges {
     template <typename T, bool Borrowed>
-    inline constexpr bool enable_borrowed_range<BasicRange<T, Borrowed>> = Borrowed;
+    constexpr bool enable_borrowed_range<BasicRange<T, Borrowed>> = Borrowed;
 }
 
 using ContiguousSizedRange = BasicRange<int>;
@@ -154,10 +154,10 @@ template <typename T, size_t Extent = dynamic_extent>
 constexpr void FunctionTakingSpan(type_identity_t<span<T, Extent>>) {}
 
 template <typename U, typename = void>
-inline constexpr bool AsWritableBytesCompilesFor = false;
+constexpr bool AsWritableBytesCompilesFor = false;
 
 template <typename U>
-inline constexpr bool AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(declval<U>()))>> = true;
+constexpr bool AsWritableBytesCompilesFor<U, void_t<decltype(as_writable_bytes(declval<U>()))>> = true;
 
 constexpr bool test() {
     {
diff --git a/tests/std/tests/P0220R1_optional/test.cpp b/tests/std/tests/P0220R1_optional/test.cpp
index 62ea78933e6..8e0604e2e7f 100644
--- a/tests/std/tests/P0220R1_optional/test.cpp
+++ b/tests/std/tests/P0220R1_optional/test.cpp
@@ -8114,7 +8114,7 @@ namespace msvc {
         struct __declspec(empty_bases) many_bases : empty<0>, empty<1>, empty<2>, empty<3> {};
 
         template <class T>
-        inline constexpr bool check_size = sizeof(std::optional<T>) == sizeof(T) + alignof(T);
+        constexpr bool check_size = sizeof(std::optional<T>) == sizeof(T) + alignof(T);
 
         STATIC_ASSERT(check_size<bool>);
         STATIC_ASSERT(check_size<char>);
diff --git a/tests/std/tests/P0448R4_spanstream/test.cpp b/tests/std/tests/P0448R4_spanstream/test.cpp
index ca3c75691a3..cf97ba7f317 100644
--- a/tests/std/tests/P0448R4_spanstream/test.cpp
+++ b/tests/std/tests/P0448R4_spanstream/test.cpp
@@ -15,17 +15,17 @@
 using namespace std;
 
 template <class CharT>
-inline constexpr auto input_ptr = "1 2 3 4 5";
+constexpr auto input_ptr = "1 2 3 4 5";
 template <>
 inline constexpr auto input_ptr<wchar_t> = L"1 2 3 4 5";
 
 template <class CharT>
-inline constexpr auto input_view = "1 2 3 4 5"sv;
+constexpr auto input_view = "1 2 3 4 5"sv;
 template <>
 inline constexpr auto input_view<wchar_t> = L"1 2 3 4 5"sv;
 
 template <class CharT>
-inline constexpr array input_std_array{'1', ' ', '2', ' ', '3', ' ', '4', ' ', '5'};
+constexpr array input_std_array{'1', ' ', '2', ' ', '3', ' ', '4', ' ', '5'};
 template <>
 inline constexpr array input_std_array<wchar_t>{L'1', L' ', L'2', L' ', L'3', L' ', L'4', L' ', L'5'};
 
diff --git a/tests/std/tests/P0768R1_spaceship_cpos/test.cpp b/tests/std/tests/P0768R1_spaceship_cpos/test.cpp
index b21ccd0efa6..350f7ec1ec7 100644
--- a/tests/std/tests/P0768R1_spaceship_cpos/test.cpp
+++ b/tests/std/tests/P0768R1_spaceship_cpos/test.cpp
@@ -34,7 +34,7 @@ template <const auto& CPO, typename E, typename F = E>
 using CpoResult = CpoResultImpl<CPO, E, F>::type;
 
 template <const auto& CPO, typename E, typename F = E>
-inline constexpr bool NoexceptCpo = noexcept(CPO(declval<E>(), declval<F>()));
+constexpr bool NoexceptCpo = noexcept(CPO(declval<E>(), declval<F>()));
 
 // Test when the decayed types differ.
 static_assert(is_same_v<CpoResult<std::strong_order, int, long>, IllFormed>); // [cmp.alg]/1.1
diff --git a/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp b/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
index 8769793dd9f..3fdcdca2b3e 100644
--- a/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
+++ b/tests/std/tests/P0784R7_library_support_for_more_constexpr_containers/test.cpp
@@ -27,7 +27,7 @@ template <class Ty>
 concept can_ranges_destroy_at = requires(Ty* ptr) { ranges::destroy_at(ptr); };
 
 template <class Ty, class... Types>
-inline constexpr bool can_construct_at = [] {
+constexpr bool can_construct_at = [] {
     constexpr bool result = can_std_construct_at<Ty, Types...>;
     static_assert(can_ranges_construct_at<Ty, Types...> == result);
     return result;
diff --git a/tests/std/tests/P0896R4_counted_iterator/test.cpp b/tests/std/tests/P0896R4_counted_iterator/test.cpp
index 4cde4ea3a67..f15a2bcc27b 100644
--- a/tests/std/tests/P0896R4_counted_iterator/test.cpp
+++ b/tests/std/tests/P0896R4_counted_iterator/test.cpp
@@ -12,11 +12,11 @@
 using namespace std;
 
 template <class>
-inline constexpr void* must_be_countable = nullptr;
+constexpr void* must_be_countable = nullptr;
 
 template <input_or_output_iterator I>
     requires requires { typename counted_iterator<I>; }
-inline constexpr bool must_be_countable<I> = true;
+constexpr bool must_be_countable<I> = true;
 
 template <class... Is>
 concept Counted = (must_be_countable<Is> && ...);
diff --git a/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp b/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
index 1eee6b591e3..42755c4908d 100644
--- a/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
+++ b/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
@@ -1015,7 +1015,7 @@ namespace special_memory_concepts {
     STATIC_ASSERT(forward_iterator<iterator_archetype<iterator_status::forward>>);
 
     template <class I>
-    inline constexpr bool has_lvalue_reference = std::is_lvalue_reference_v<std::iter_reference_t<I>>;
+    constexpr bool has_lvalue_reference = std::is_lvalue_reference_v<std::iter_reference_t<I>>;
     STATIC_ASSERT(has_lvalue_reference<iterator_archetype<iterator_status::not_input>>);
     STATIC_ASSERT(!has_lvalue_reference<iterator_archetype<iterator_status::not_lvalue_reference>>);
     STATIC_ASSERT(has_lvalue_reference<iterator_archetype<iterator_status::different_reference_and_value>>);
@@ -1023,7 +1023,7 @@ namespace special_memory_concepts {
     STATIC_ASSERT(has_lvalue_reference<iterator_archetype<iterator_status::forward>>);
 
     template <class I>
-    inline constexpr bool same_reference_value =
+    constexpr bool same_reference_value =
         std::same_as<std::remove_cvref_t<std::iter_reference_t<I>>, std::iter_value_t<I>>;
     STATIC_ASSERT(same_reference_value<iterator_archetype<iterator_status::not_input>>);
     STATIC_ASSERT(same_reference_value<iterator_archetype<iterator_status::not_lvalue_reference>>);
diff --git a/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp b/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp
index 70f50d2d7fc..d95996ad196 100644
--- a/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_iterator_machinery/test.cpp
@@ -453,7 +453,7 @@ std::iter_difference_t<iterator_archetype<J>> operator-(
     iterator_archetype<J> const&, sized_sentinel_archetype<I> const&);
 
 template <class I>
-inline constexpr bool std::disable_sized_sentinel_for<sized_sentinel_archetype<11>, I> = true;
+constexpr bool std::disable_sized_sentinel_for<sized_sentinel_archetype<11>, I> = true;
 
 inline constexpr std::size_t sized_sentinel_archetype_max = 12;
 
diff --git a/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp b/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp
index aeb55dc9bdb..813e1240c6b 100644
--- a/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp
+++ b/tests/std/tests/P0896R4_ranges_subrange/test.compile.pass.cpp
@@ -989,9 +989,9 @@ namespace test_subrange {
 
     // Validate many properties of a specialization of subrange
     template <class>
-    inline constexpr bool is_subrange = false;
+    constexpr bool is_subrange = false;
     template <class I, class S, subrange_kind K>
-    inline constexpr bool is_subrange<subrange<I, S, K>> = true;
+    constexpr bool is_subrange<subrange<I, S, K>> = true;
 
     template <class T>
     struct illformed {
@@ -999,9 +999,9 @@ namespace test_subrange {
     };
 
     template <class T>
-    inline constexpr auto kind_of = illformed<T>{};
+    constexpr auto kind_of = illformed<T>{};
     template <class I, class S, subrange_kind K>
-    inline constexpr auto kind_of<subrange<I, S, K>> = K;
+    constexpr auto kind_of<subrange<I, S, K>> = K;
 
     template <class Subrange, class Rng>
     constexpr bool test_subrange() {
diff --git a/tests/std/tests/P0896R4_ranges_to_address/test.cpp b/tests/std/tests/P0896R4_ranges_to_address/test.cpp
index 0126dd8cd1c..0e737e2286a 100644
--- a/tests/std/tests/P0896R4_ranges_to_address/test.cpp
+++ b/tests/std/tests/P0896R4_ranges_to_address/test.cpp
@@ -10,9 +10,9 @@
 #include <test_death.hpp>
 
 template <class, template <class...> class>
-inline constexpr bool is_specialization = false;
+constexpr bool is_specialization = false;
 template <class... Args, template <class...> class T>
-inline constexpr bool is_specialization<T<Args...>, T> = true;
+constexpr bool is_specialization<T<Args...>, T> = true;
 
 template <bool IsConst, class C>
 using maybe_const_iter = std::conditional_t<IsConst, typename C::const_iterator, typename C::iterator>;
diff --git a/tests/std/tests/P0896R4_views_drop/test.cpp b/tests/std/tests/P0896R4_views_drop/test.cpp
index 0cd53ead1ba..1fb53adc1e6 100644
--- a/tests/std/tests/P0896R4_views_drop/test.cpp
+++ b/tests/std/tests/P0896R4_views_drop/test.cpp
@@ -38,9 +38,9 @@ struct evil_convertible_to_difference {
 constexpr auto pipeline = views::drop(1) | views::drop(1) | views::drop(1) | views::drop(1);
 
 template <class>
-inline constexpr bool is_subrange = false;
+constexpr bool is_subrange = false;
 template <class I, class S, ranges::subrange_kind K>
-inline constexpr bool is_subrange<ranges::subrange<I, S, K>> = true;
+constexpr bool is_subrange<ranges::subrange<I, S, K>> = true;
 
 template <class>
 struct mapped {
diff --git a/tests/std/tests/P0896R4_views_take/test.cpp b/tests/std/tests/P0896R4_views_take/test.cpp
index bf3a3209956..331e313d65a 100644
--- a/tests/std/tests/P0896R4_views_take/test.cpp
+++ b/tests/std/tests/P0896R4_views_take/test.cpp
@@ -41,9 +41,9 @@ struct evil_convertible_to_difference {
 constexpr auto pipeline = views::take(7) | views::take(6) | views::take(5) | views::take(4);
 
 template <class>
-inline constexpr bool is_subrange = false;
+constexpr bool is_subrange = false;
 template <class I, class S, ranges::subrange_kind K>
-inline constexpr bool is_subrange<ranges::subrange<I, S, K>> = true;
+constexpr bool is_subrange<ranges::subrange<I, S, K>> = true;
 
 template <class>
 struct mapped {
diff --git a/tests/std/tests/P1614R2_spaceship/test.cpp b/tests/std/tests/P1614R2_spaceship/test.cpp
index 6b7ba2df1d4..d333dcfbeef 100644
--- a/tests/std/tests/P1614R2_spaceship/test.cpp
+++ b/tests/std/tests/P1614R2_spaceship/test.cpp
@@ -172,9 +172,9 @@ constexpr bool spaceship_test(const SmallType& smaller, const EqualType& smaller
 }
 
 template <class T>
-inline constexpr bool has_synth_ordered = false;
+constexpr bool has_synth_ordered = false;
 template <class V>
-inline constexpr bool has_synth_ordered<std::pair<const SynthOrdered, V>> = true;
+constexpr bool has_synth_ordered<std::pair<const SynthOrdered, V>> = true;
 template <>
 inline constexpr bool has_synth_ordered<SynthOrdered> = true;
 
diff --git a/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp b/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp
index 79eca27f324..6f2c29c9383 100644
--- a/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp
+++ b/tests/std/tests/P2165R4_tuple_like_common_type/test.compile.pass.cpp
@@ -15,8 +15,7 @@ concept CanCommonType = requires { typename common_type<T, U>::type; };
 
 template <class T, class U, class Expected>
     requires CanCommonType<T, U>
-inline constexpr bool test_common_type =
-    same_as<common_type_t<T, U>, Expected> && same_as<common_type_t<U, T>, Expected>;
+constexpr bool test_common_type = same_as<common_type_t<T, U>, Expected> && same_as<common_type_t<U, T>, Expected>;
 
 struct Sentinel {
     bool operator==(const auto&) const; // not defined

From 834626585c60929e1dbc98599c2e4c1be0e310e2 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 10 Apr 2024 00:25:32 +0300
Subject: [PATCH 31/45] Manually vectorize for at least SSE4.2 (#4550)

---
 stl/src/vector_algorithms.cpp | 136 ++++++++++++++--------------------
 1 file changed, 54 insertions(+), 82 deletions(-)

diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index 321dd09ebeb..21c0a4c30e2 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -30,14 +30,6 @@ namespace {
         return __isa_enabled & (1 << __ISA_AVAILABLE_SSE42);
     }
 
-    bool _Use_sse2() noexcept {
-#ifdef _M_IX86
-        return __isa_enabled & (1 << __ISA_AVAILABLE_SSE2);
-#else
-        return true;
-#endif
-    }
-
     struct [[nodiscard]] _Zeroupper_on_exit { // TRANSITION, DevCom-10331414
         _Zeroupper_on_exit() = default;
 
@@ -118,7 +110,7 @@ __declspec(noalias) void __cdecl __std_swap_ranges_trivially_swappable_noalias(
     }
 
     constexpr size_t _Mask_16 = ~((static_cast<size_t>(1) << 4) - 1);
-    if (_Byte_length(_First1, _Last1) >= 16 && _Use_sse2()) {
+    if (_Byte_length(_First1, _Last1) >= 16 && _Use_sse42()) {
         const void* _Stop_at = _First1;
         _Advance_bytes(_Stop_at, _Byte_length(_First1, _Last1) & _Mask_16);
         do {
@@ -214,7 +206,7 @@ __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_1(void* _Firs
             _Advance_bytes(_Last, -16);
             const __m128i _Left           = _mm_loadu_si128(static_cast<__m128i*>(_First));
             const __m128i _Right          = _mm_loadu_si128(static_cast<__m128i*>(_Last));
-            const __m128i _Left_reversed  = _mm_shuffle_epi8(_Left, _Reverse_char_sse); // SSSE3
+            const __m128i _Left_reversed  = _mm_shuffle_epi8(_Left, _Reverse_char_sse);
             const __m128i _Right_reversed = _mm_shuffle_epi8(_Right, _Reverse_char_sse);
             _mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
             _mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
@@ -258,7 +250,7 @@ __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_2(void* _Firs
             _Advance_bytes(_Last, -16);
             const __m128i _Left           = _mm_loadu_si128(static_cast<__m128i*>(_First));
             const __m128i _Right          = _mm_loadu_si128(static_cast<__m128i*>(_Last));
-            const __m128i _Left_reversed  = _mm_shuffle_epi8(_Left, _Reverse_short_sse); // SSSE3
+            const __m128i _Left_reversed  = _mm_shuffle_epi8(_Left, _Reverse_short_sse);
             const __m128i _Right_reversed = _mm_shuffle_epi8(_Right, _Reverse_short_sse);
             _mm_storeu_si128(static_cast<__m128i*>(_First), _Right_reversed);
             _mm_storeu_si128(static_cast<__m128i*>(_Last), _Left_reversed);
@@ -290,7 +282,7 @@ __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_4(void* _Firs
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
     }
 
-    if (_Byte_length(_First, _Last) >= 32 && _Use_sse2()) {
+    if (_Byte_length(_First, _Last) >= 32 && _Use_sse42()) {
         const void* _Stop_at = _First;
         _Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0xF});
         do {
@@ -328,7 +320,7 @@ __declspec(noalias) void __cdecl __std_reverse_trivially_swappable_8(void* _Firs
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
     }
 
-    if (_Byte_length(_First, _Last) >= 32 && _Use_sse2()) {
+    if (_Byte_length(_First, _Last) >= 32 && _Use_sse42()) {
         const void* _Stop_at = _First;
         _Advance_bytes(_Stop_at, (_Byte_length(_First, _Last) >> 1) & ~size_t{0xF});
         do {
@@ -375,7 +367,7 @@ __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_1(
         do {
             _Advance_bytes(_Last, -16);
             const __m128i _Block          = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
-            const __m128i _Block_reversed = _mm_shuffle_epi8(_Block, _Reverse_char_sse); // SSSE3
+            const __m128i _Block_reversed = _mm_shuffle_epi8(_Block, _Reverse_char_sse);
             _mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
             _Advance_bytes(_Dest, 16);
         } while (_Dest != _Stop_at);
@@ -414,7 +406,7 @@ __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_2(
         do {
             _Advance_bytes(_Last, -16);
             const __m128i _Block          = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
-            const __m128i _Block_reversed = _mm_shuffle_epi8(_Block, _Reverse_short_sse); // SSSE3
+            const __m128i _Block_reversed = _mm_shuffle_epi8(_Block, _Reverse_short_sse);
             _mm_storeu_si128(static_cast<__m128i*>(_Dest), _Block_reversed);
             _Advance_bytes(_Dest, 16);
         } while (_Dest != _Stop_at);
@@ -443,7 +435,7 @@ __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_4(
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
     }
 
-    if (_Byte_length(_First, _Last) >= 16 && _Use_sse2()) {
+    if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
         const void* _Stop_at = _Dest;
         _Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0xF});
         do {
@@ -477,7 +469,7 @@ __declspec(noalias) void __cdecl __std_reverse_copy_trivially_copyable_8(
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
     }
 
-    if (_Byte_length(_First, _Last) >= 16 && _Use_sse2()) {
+    if (_Byte_length(_First, _Last) >= 16 && _Use_sse42()) {
         const void* _Stop_at = _Dest;
         _Advance_bytes(_Stop_at, _Byte_length(_First, _Last) & ~size_t{0xF});
         do {
@@ -585,17 +577,17 @@ namespace {
             __m128i _H_min_val = _Cur;
             _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
             _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
-            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_words)); // SSSE3
-            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_bytes)); // SSSE3
+            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_words));
+            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_bytes));
             return _H_min_val;
         }
 
         static __m128i _H_min(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epi8(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epi8(_Val1, _Val2); });
         }
 
         static __m128i _H_max(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epi8(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epi8(_Val1, _Val2); });
         }
 
         static __m128i _H_min_u(const __m128i _Cur) noexcept {
@@ -611,7 +603,6 @@ namespace {
         }
 
         static _Unsigned_t _Get_v_pos(const __m128i _Idx, const unsigned long _H_pos) noexcept {
-            // _mm_shuffle_epi8 is SSSE3:
             return static_cast<_Unsigned_t>(_mm_cvtsi128_si32(_mm_shuffle_epi8(_Idx, _mm_cvtsi32_si128(_H_pos))));
         }
 
@@ -628,11 +619,11 @@ namespace {
         }
 
         static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
-            return _mm_min_epi8(_First, _Second); // SSE4.1
+            return _mm_min_epi8(_First, _Second);
         }
 
         static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
-            return _mm_max_epi8(_First, _Second); // SSE4.1
+            return _mm_max_epi8(_First, _Second);
         }
 
         static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
@@ -686,7 +677,7 @@ namespace {
             __m128i _H_min_val = _Cur;
             _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(1, 0, 3, 2)));
             _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi32(_H_min_val, _MM_SHUFFLE(2, 3, 0, 1)));
-            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_words)); // SSSE3
+            _H_min_val         = _Funct(_H_min_val, _mm_shuffle_epi8(_H_min_val, _Shuf_words));
             return _H_min_val;
         }
 
@@ -699,11 +690,11 @@ namespace {
         }
 
         static __m128i _H_min_u(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epu16(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epu16(_Val1, _Val2); });
         }
 
         static __m128i _H_max_u(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epu16(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epu16(_Val1, _Val2); });
         }
 
         static _Signed_t _Get_any(const __m128i _Cur) noexcept {
@@ -713,7 +704,6 @@ namespace {
         static _Unsigned_t _Get_v_pos(const __m128i _Idx, const unsigned long _H_pos) noexcept {
             static constexpr _Unsigned_t _Shuf[] = {0x0100, 0x0302, 0x0504, 0x0706, 0x0908, 0x0B0A, 0x0D0C, 0x0F0E};
 
-            // _mm_shuffle_epi8 is SSSE3:
             return static_cast<_Unsigned_t>(
                 _mm_cvtsi128_si32(_mm_shuffle_epi8(_Idx, _mm_cvtsi32_si128(_Shuf[_H_pos >> 1]))));
         }
@@ -739,11 +729,11 @@ namespace {
         }
 
         static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_min_epu16(_First, _Second); // SSE4.1
+            return _mm_min_epu16(_First, _Second);
         }
 
         static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_max_epu16(_First, _Second); // SSE4.1
+            return _mm_max_epu16(_First, _Second);
         }
 
         static __m128i _Mask_cast(__m128i _Mask) noexcept {
@@ -795,19 +785,19 @@ namespace {
         }
 
         static __m128i _H_min(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epi32(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epi32(_Val1, _Val2); });
         }
 
         static __m128i _H_max(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epi32(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epi32(_Val1, _Val2); });
         }
 
         static __m128i _H_min_u(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epu32(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epu32(_Val1, _Val2); });
         }
 
         static __m128i _H_max_u(const __m128i _Cur) noexcept {
-            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epu32(_Val1, _Val2); }); // SSE4.1
+            return _H_func(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epu32(_Val1, _Val2); });
         }
 
         static _Signed_t _Get_any(const __m128i _Cur) noexcept {
@@ -833,19 +823,19 @@ namespace {
         }
 
         static __m128i _Min(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
-            return _mm_min_epi32(_First, _Second); // SSE4.1
+            return _mm_min_epi32(_First, _Second);
         }
 
         static __m128i _Max(const __m128i _First, const __m128i _Second, __m128i = _mm_undefined_si128()) noexcept {
-            return _mm_max_epi32(_First, _Second); // SSE4.1
+            return _mm_max_epi32(_First, _Second);
         }
 
         static __m128i _Min_u(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_min_epu32(_First, _Second); // SSE4.1
+            return _mm_min_epu32(_First, _Second);
         }
 
         static __m128i _Max_u(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_max_epu32(_First, _Second); // SSE4.1
+            return _mm_max_epu32(_First, _Second);
         }
 
         static __m128i _Mask_cast(__m128i _Mask) noexcept {
@@ -912,7 +902,7 @@ namespace {
         static _Signed_t _Get_any(const __m128i _Cur) noexcept {
 #ifdef _M_IX86
             return static_cast<_Signed_t>(
-                (static_cast<_Unsigned_t>(static_cast<uint32_t>(_mm_extract_epi32(_Cur, 1))) << 32) // SSE4.1
+                (static_cast<_Unsigned_t>(static_cast<uint32_t>(_mm_extract_epi32(_Cur, 1))) << 32)
                 | static_cast<_Unsigned_t>(static_cast<uint32_t>(_mm_cvtsi128_si32(_Cur))));
 #else // ^^^ x86 / x64 vvv
             return static_cast<_Signed_t>(_mm_cvtsi128_si64(_Cur));
@@ -926,31 +916,31 @@ namespace {
         }
 
         static __m128i _Cmp_eq(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_cmpeq_epi64(_First, _Second); // SSE4.1
+            return _mm_cmpeq_epi64(_First, _Second);
         }
 
         static __m128i _Cmp_gt(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_cmpgt_epi64(_First, _Second); // SSE4.2
+            return _mm_cmpgt_epi64(_First, _Second);
         }
 
         static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_cmpeq_epi64(_First, _Second); // SSE4.1
+            return _mm_cmpeq_epi64(_First, _Second);
         }
 
         static __m128i _Min(const __m128i _First, const __m128i _Second, const __m128i _Mask) noexcept {
-            return _mm_blendv_epi8(_First, _Second, _Mask); // SSE4.1
+            return _mm_blendv_epi8(_First, _Second, _Mask);
         }
 
         static __m128i _Max(const __m128i _First, const __m128i _Second, const __m128i _Mask) noexcept {
-            return _mm_blendv_epi8(_First, _Second, _Mask); // SSE4.1
+            return _mm_blendv_epi8(_First, _Second, _Mask);
         }
 
         static __m128i _Min(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_blendv_epi8(_First, _Second, _Cmp_gt(_First, _Second)); // _Cmp_gt is SSE4.2
+            return _mm_blendv_epi8(_First, _Second, _Cmp_gt(_First, _Second));
         }
 
         static __m128i _Max(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_blendv_epi8(_First, _Second, _Cmp_gt(_Second, _First)); // _Cmp_gt is SSE4.2
+            return _mm_blendv_epi8(_First, _Second, _Cmp_gt(_Second, _First));
         }
 
         static __m128i _Mask_cast(__m128i _Mask) noexcept {
@@ -1016,11 +1006,11 @@ namespace {
         }
 
         static __m128i _H_min_u(const __m128i _Cur) noexcept {
-            return _H_func_u(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epu32(_Val1, _Val2); }); // SSE4.1
+            return _H_func_u(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_min_epu32(_Val1, _Val2); });
         }
 
         static __m128i _H_max_u(const __m128i _Cur) noexcept {
-            return _H_func_u(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epu32(_Val1, _Val2); }); // SSE4.1
+            return _H_func_u(_Cur, [](__m128i _Val1, __m128i _Val2) { return _mm_max_epu32(_Val1, _Val2); });
         }
 
         static float _Get_any(const __m128 _Cur) noexcept {
@@ -1124,7 +1114,7 @@ namespace {
 
         static uint64_t _Get_any_u(const __m128i _Cur) noexcept {
 #ifdef _M_IX86
-            return (static_cast<uint64_t>(static_cast<uint32_t>(_mm_extract_epi32(_Cur, 1))) << 32) // SSE4.1
+            return (static_cast<uint64_t>(static_cast<uint32_t>(_mm_extract_epi32(_Cur, 1))) << 32)
                  | static_cast<uint64_t>(static_cast<uint32_t>(_mm_cvtsi128_si32(_Cur)));
 #else // ^^^ x86 / x64 vvv
             return static_cast<uint64_t>(_mm_cvtsi128_si64(_Cur));
@@ -1146,7 +1136,7 @@ namespace {
         }
 
         static __m128i _Cmp_eq_idx(const __m128i _First, const __m128i _Second) noexcept {
-            return _mm_cmpeq_epi64(_First, _Second); // SSE4.1
+            return _mm_cmpeq_epi64(_First, _Second);
         }
 
         static __m128d _Min(const __m128d _First, const __m128d _Second, __m128d = _mm_undefined_pd()) noexcept {
@@ -1751,7 +1741,7 @@ namespace {
         }
 
         static __m128i _Set_sse(const uint8_t _Val) noexcept {
-            return _mm_set1_epi8(_Val);
+            return _mm_shuffle_epi8(_mm_cvtsi32_si128(_Val), _mm_setzero_si128());
         }
 
         static __m256i _Cmp_avx(const __m256i _Lhs, const __m256i _Rhs) noexcept {
@@ -1761,10 +1751,6 @@ namespace {
         static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
             return _mm_cmpeq_epi8(_Lhs, _Rhs);
         }
-
-        static bool _Sse_available() noexcept {
-            return _Use_sse2();
-        }
 #endif // !_M_ARM64EC
     };
 
@@ -1787,10 +1773,6 @@ namespace {
         static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
             return _mm_cmpeq_epi16(_Lhs, _Rhs);
         }
-
-        static bool _Sse_available() noexcept {
-            return _Use_sse2();
-        }
 #endif // !_M_ARM64EC
     };
 
@@ -1813,10 +1795,6 @@ namespace {
         static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
             return _mm_cmpeq_epi32(_Lhs, _Rhs);
         }
-
-        static bool _Sse_available() noexcept {
-            return _Use_sse2();
-        }
 #endif // !_M_ARM64EC
     };
 
@@ -1837,11 +1815,7 @@ namespace {
         }
 
         static __m128i _Cmp_sse(const __m128i _Lhs, const __m128i _Rhs) noexcept {
-            return _mm_cmpeq_epi64(_Lhs, _Rhs); // SSE4.1
-        }
-
-        static bool _Sse_available() noexcept {
-            return _Use_sse42(); // for pcmpeqq on _Cmp_sse
+            return _mm_cmpeq_epi64(_Lhs, _Rhs);
         }
 #endif // !_M_ARM64EC
     };
@@ -1888,7 +1862,7 @@ namespace {
         }
 
         const size_t _Sse_size = _Size_bytes & ~size_t{0xF};
-        if (_Sse_size != 0 && _Traits::_Sse_available()) {
+        if (_Sse_size != 0 && _Use_sse42()) {
             const __m128i _Comparand = _Traits::_Set_sse(_Val);
             const void* _Stop_at     = _First;
             _Advance_bytes(_Stop_at, _Sse_size);
@@ -1942,7 +1916,7 @@ namespace {
         }
 
         const size_t _Sse_size = _Size_bytes & ~size_t{0xF};
-        if (_Sse_size != 0 && _Traits::_Sse_available()) {
+        if (_Sse_size != 0 && _Use_sse42()) {
             const __m128i _Comparand = _Traits::_Set_sse(_Val);
             const void* _Stop_at     = _Last;
             _Rewind_bytes(_Stop_at, _Sse_size);
@@ -2130,7 +2104,7 @@ namespace {
             if constexpr (sizeof(_Ty) >= 4) {
                 return _Result;
             }
-        } else if (_Traits::_Sse_available()) {
+        } else if (_Use_sse42()) {
             const size_t _Count_bytes_sse = (_Count * sizeof(_Ty)) & ~size_t{0xF};
 
             for (; _Result != _Count_bytes_sse; _Result += 0x10) {
@@ -2291,12 +2265,10 @@ namespace {
 
     __m128i __forceinline _Bitset_to_string_1_step(const uint16_t _Val, const __m128i _Px0, const __m128i _Px1) {
         const __m128i _Vx0 = _mm_cvtsi32_si128(_Val);
-        const __m128i _Vx1 = _mm_unpacklo_epi8(_Vx0, _Vx0);
-        const __m128i _Vx2 = _mm_unpacklo_epi8(_Vx1, _Vx1);
-        const __m128i _Vx3 = _mm_shuffle_epi32(_Vx2, _MM_SHUFFLE(0, 0, 1, 1));
-        const __m128i _Msk = _mm_and_si128(_Vx3, _mm_set1_epi64x(0x0102040810204080));
+        const __m128i _Vx1 = _mm_shuffle_epi8(_Vx0, _mm_set_epi32(0x00000000, 0x00000000, 0x01010101, 0x01010101));
+        const __m128i _Msk = _mm_and_si128(_Vx1, _mm_set1_epi64x(0x0102040810204080));
         const __m128i _Ex0 = _mm_cmpeq_epi8(_Msk, _mm_setzero_si128());
-        const __m128i _Ex1 = _mm_xor_si128(_mm_and_si128(_Ex0, _Px0), _Px1);
+        const __m128i _Ex1 = _mm_blendv_epi8(_Px1, _Px0, _Ex0);
         return _Ex1;
     }
 
@@ -2316,7 +2288,7 @@ namespace {
         const __m128i _Vx  = _mm_set1_epi16(_Val);
         const __m128i _Msk = _mm_and_si128(_Vx, _mm_set_epi64x(0x0001000200040008, 0x0010002000400080));
         const __m128i _Ex0 = _mm_cmpeq_epi16(_Msk, _mm_setzero_si128());
-        const __m128i _Ex1 = _mm_xor_si128(_mm_and_si128(_Ex0, _Px0), _Px1);
+        const __m128i _Ex1 = _mm_blendv_epi8(_Px1, _Px0, _Ex0);
         return _Ex1;
     }
 } // unnamed namespace
@@ -2356,9 +2328,9 @@ __declspec(noalias) void __stdcall __std_bitset_to_string_1(
         }
 
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
-    } else if (_Use_sse2()) {
-        const __m128i _Px0 = _mm_set1_epi8(_Elem0 ^ _Elem1);
-        const __m128i _Px1 = _mm_set1_epi8(_Elem1);
+    } else if (_Use_sse42()) {
+        const __m128i _Px0 = _mm_shuffle_epi8(_mm_cvtsi32_si128(_Elem0), _mm_setzero_si128());
+        const __m128i _Px1 = _mm_shuffle_epi8(_mm_cvtsi32_si128(_Elem1), _mm_setzero_si128());
         if (_Size_bits >= 16) {
             char* _Pos = _Dest + _Size_bits;
             _Size_bits &= 0xF;
@@ -2436,8 +2408,8 @@ __declspec(noalias) void __stdcall __std_bitset_to_string_2(
         }
 
         _mm256_zeroupper(); // TRANSITION, DevCom-10331414
-    } else if (_Use_sse2()) {
-        const __m128i _Px0 = _mm_set1_epi16(_Elem0 ^ _Elem1);
+    } else if (_Use_sse42()) {
+        const __m128i _Px0 = _mm_set1_epi16(_Elem0);
         const __m128i _Px1 = _mm_set1_epi16(_Elem1);
         if (_Size_bits >= 8) {
             wchar_t* _Pos = _Dest + _Size_bits;

From f5bccb8b4ea6cba4584039895b31e0dab0c15839 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Wed, 10 Apr 2024 05:54:17 +0800
Subject: [PATCH 32/45] `<ranges>`: Check and test preconditions for
 `take_view` and `drop_view`'s constructors (#4551)

---
 stl/inc/ranges                                |  8 ++++--
 tests/std/test.lst                            |  2 ++
 .../tests/P0896R4_views_drop_death/env.lst    |  4 +++
 .../tests/P0896R4_views_drop_death/test.cpp   | 27 +++++++++++++++++++
 .../tests/P0896R4_views_take_death/env.lst    |  4 +++
 .../tests/P0896R4_views_take_death/test.cpp   | 27 +++++++++++++++++++
 6 files changed, 70 insertions(+), 2 deletions(-)
 create mode 100644 tests/std/tests/P0896R4_views_drop_death/env.lst
 create mode 100644 tests/std/tests/P0896R4_views_drop_death/test.cpp
 create mode 100644 tests/std/tests/P0896R4_views_take_death/env.lst
 create mode 100644 tests/std/tests/P0896R4_views_take_death/test.cpp

diff --git a/stl/inc/ranges b/stl/inc/ranges
index 07e70c345d6..6ceaec735d5 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -2947,7 +2947,11 @@ namespace ranges {
 
         constexpr explicit take_view(_Vw _Range_, const range_difference_t<_Vw> _Count_) noexcept(
             is_nothrow_move_constructible_v<_Vw>) // strengthened
-            : _Range(_STD move(_Range_)), _Count{_Count_} {}
+            : _Range(_STD move(_Range_)), _Count{_Count_} {
+#if _CONTAINER_DEBUG_LEVEL > 0
+            _STL_VERIFY(_Count_ >= 0, "Number of elements to take must be non-negative (N4971 [range.take.view]/1)");
+#endif // _CONTAINER_DEBUG_LEVEL > 0
+        }
 
         _NODISCARD constexpr _Vw base() const& noexcept(is_nothrow_copy_constructible_v<_Vw>) /* strengthened */
             requires copy_constructible<_Vw>
@@ -3365,7 +3369,7 @@ namespace ranges {
             is_nothrow_move_constructible_v<_Vw>) // strengthened
             : _Range(_STD move(_Range_)), _Count{_Count_} {
 #if _CONTAINER_DEBUG_LEVEL > 0
-            _STL_VERIFY(_Count_ >= 0, "Number of elements to drop must be non-negative (N4950 [range.drop.view]/1");
+            _STL_VERIFY(_Count_ >= 0, "Number of elements to drop must be non-negative (N4971 [range.drop.view]/1)");
 #endif // _CONTAINER_DEBUG_LEVEL > 0
         }
 
diff --git a/tests/std/test.lst b/tests/std/test.lst
index a3ec79e1268..13dec80ac31 100644
--- a/tests/std/test.lst
+++ b/tests/std/test.lst
@@ -480,6 +480,7 @@ tests\P0896R4_views_common
 tests\P0896R4_views_counted
 tests\P0896R4_views_counted_death
 tests\P0896R4_views_drop
+tests\P0896R4_views_drop_death
 tests\P0896R4_views_drop_while
 tests\P0896R4_views_drop_while_death
 tests\P0896R4_views_elements
@@ -495,6 +496,7 @@ tests\P0896R4_views_reverse
 tests\P0896R4_views_single
 tests\P0896R4_views_split
 tests\P0896R4_views_take
+tests\P0896R4_views_take_death
 tests\P0896R4_views_take_while
 tests\P0896R4_views_take_while_death
 tests\P0896R4_views_transform
diff --git a/tests/std/tests/P0896R4_views_drop_death/env.lst b/tests/std/tests/P0896R4_views_drop_death/env.lst
new file mode 100644
index 00000000000..351a8293d9d
--- /dev/null
+++ b/tests/std/tests/P0896R4_views_drop_death/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_20_matrix.lst
diff --git a/tests/std/tests/P0896R4_views_drop_death/test.cpp b/tests/std/tests/P0896R4_views_drop_death/test.cpp
new file mode 100644
index 00000000000..9205b10aa75
--- /dev/null
+++ b/tests/std/tests/P0896R4_views_drop_death/test.cpp
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#define _CONTAINER_DEBUG_LEVEL 1
+
+#include <ranges>
+
+#include <test_death.hpp>
+using namespace std;
+
+constexpr int some_ints[] = {0, 1, 2, 3};
+
+void test_constructor_negative_size() {
+    (void) views::drop(some_ints, -3); // Number of elements to drop must be non-negative
+}
+
+int main(int argc, char* argv[]) {
+    std_testing::death_test_executive exec;
+
+#ifdef _DEBUG
+    exec.add_death_tests({
+        test_constructor_negative_size,
+    });
+#endif // _DEBUG
+
+    return exec.run(argc, argv);
+}
diff --git a/tests/std/tests/P0896R4_views_take_death/env.lst b/tests/std/tests/P0896R4_views_take_death/env.lst
new file mode 100644
index 00000000000..351a8293d9d
--- /dev/null
+++ b/tests/std/tests/P0896R4_views_take_death/env.lst
@@ -0,0 +1,4 @@
+# Copyright (c) Microsoft Corporation.
+# SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+RUNALL_INCLUDE ..\usual_20_matrix.lst
diff --git a/tests/std/tests/P0896R4_views_take_death/test.cpp b/tests/std/tests/P0896R4_views_take_death/test.cpp
new file mode 100644
index 00000000000..54c26053f52
--- /dev/null
+++ b/tests/std/tests/P0896R4_views_take_death/test.cpp
@@ -0,0 +1,27 @@
+// Copyright (c) Microsoft Corporation.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+
+#define _CONTAINER_DEBUG_LEVEL 1
+
+#include <ranges>
+
+#include <test_death.hpp>
+using namespace std;
+
+constexpr int some_ints[] = {0, 1, 2, 3};
+
+void test_constructor_negative_size() {
+    (void) views::take(some_ints, -3); // Number of elements to take must be non-negative
+}
+
+int main(int argc, char* argv[]) {
+    std_testing::death_test_executive exec;
+
+#ifdef _DEBUG
+    exec.add_death_tests({
+        test_constructor_negative_size,
+    });
+#endif // _DEBUG
+
+    return exec.run(argc, argv);
+}

From bed267366d45350bc4efa1b245da78999e2bfaca Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 10 Apr 2024 01:08:21 +0300
Subject: [PATCH 33/45] vectorize `replace` (#4554)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/src/replace.cpp                    | 15 ++++
 stl/inc/algorithm                             | 68 ++++++++++++++++
 stl/inc/xutility                              | 42 +++++-----
 stl/src/vector_algorithms.cpp                 | 77 +++++++++++++++++++
 .../VSO_0000000_vector_algorithms/test.cpp    | 52 +++++++++++++
 5 files changed, 235 insertions(+), 19 deletions(-)

diff --git a/benchmarks/src/replace.cpp b/benchmarks/src/replace.cpp
index 8fc66ab7841..fe5bc68641a 100644
--- a/benchmarks/src/replace.cpp
+++ b/benchmarks/src/replace.cpp
@@ -37,6 +37,17 @@ const char src[] =
     "euismod eros, ut posuere ligula ullamcorper id. Nullam aliquam malesuada est at dignissim. Pellentesque finibus "
     "sagittis libero nec bibendum. Phasellus dolor ipsum, finibus quis turpis quis, mollis interdum felis.";
 
+template <class T>
+void r(benchmark::State& state) {
+    const std::vector<T> a(std::begin(src), std::end(src));
+    std::vector<T> b(std::size(src));
+
+    for (auto _ : state) {
+        b = a;
+        std::replace(std::begin(b), std::end(b), T{'m'}, T{'w'});
+    }
+}
+
 template <class T>
 void rc(benchmark::State& state) {
     const std::vector<T> a(std::begin(src), std::end(src));
@@ -58,6 +69,10 @@ void rc_if(benchmark::State& state) {
     }
 }
 
+// replace() is vectorized for 4 and 8 bytes only.
+BENCHMARK(r<std::uint32_t>);
+BENCHMARK(r<std::uint64_t>);
+
 BENCHMARK(rc<std::uint8_t>);
 BENCHMARK(rc<std::uint16_t>);
 BENCHMARK(rc<std::uint32_t>);
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index e01f5629680..761031054d1 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -73,6 +73,12 @@ __declspec(noalias) _Min_max_8i __stdcall __std_minmax_8i(const void* _First, co
 __declspec(noalias) _Min_max_8u __stdcall __std_minmax_8u(const void* _First, const void* _Last) noexcept;
 __declspec(noalias) _Min_max_f __stdcall __std_minmax_f(const void* _First, const void* _Last) noexcept;
 __declspec(noalias) _Min_max_d __stdcall __std_minmax_d(const void* _First, const void* _Last) noexcept;
+
+// TRANSITION, DevCom-10610477
+__declspec(noalias) void __stdcall __std_replace_4(
+    void* _First, void* _Last, uint32_t _Old_val, uint32_t _New_val) noexcept;
+__declspec(noalias) void __stdcall __std_replace_8(
+    void* _First, void* _Last, uint64_t _Old_val, uint64_t _New_val) noexcept;
 } // extern "C"
 
 _STD_BEGIN
@@ -201,6 +207,24 @@ _Ty1* _Find_first_of_vectorized(
     }
 }
 
+template <class _Ty, class _TVal1, class _TVal2>
+__declspec(noalias) void _Replace_vectorized(
+    _Ty* const _First, _Ty* const _Last, const _TVal1 _Old_val, const _TVal2 _New_val) noexcept {
+    if constexpr (is_pointer_v<_Ty>) {
+#ifdef _WIN64
+        ::__std_replace_8(_First, _Last, reinterpret_cast<uint64_t>(_Old_val), reinterpret_cast<uint64_t>(_New_val));
+#else // ^^^ defined(_WIN64) / !defined(_WIN64) vvv
+        ::__std_replace_4(_First, _Last, reinterpret_cast<uint32_t>(_Old_val), reinterpret_cast<uint32_t>(_New_val));
+#endif // ^^^ !defined(_WIN64) ^^^
+    } else if constexpr (sizeof(_Ty) == 4) {
+        ::__std_replace_4(_First, _Last, static_cast<uint32_t>(_Old_val), static_cast<uint32_t>(_New_val));
+    } else if constexpr (sizeof(_Ty) == 8) {
+        ::__std_replace_8(_First, _Last, static_cast<uint64_t>(_Old_val), static_cast<uint64_t>(_New_val));
+    } else {
+        static_assert(_Always_false<_Ty>, "Unexpected size");
+    }
+}
+
 // find_first_of vectorization is likely to be a win after this size (in elements)
 _INLINE_VAR constexpr ptrdiff_t _Threshold_find_first_of = 16;
 
@@ -209,6 +233,17 @@ template <class _It1, class _It2, class _Pr>
 constexpr bool _Vector_alg_in_find_first_of_is_safe =
     _Equal_memcmp_is_safe<_It1, _It2, _Pr> // can replace value comparison with bitwise comparison
     && sizeof(_Iter_value_t<_It1>) <= 2; // pcmpestri compatible size
+
+// Can we activate the vector algorithms for replace?
+template <class _Iter, class _Ty1>
+constexpr bool _Vector_alg_in_replace_is_safe = _Vector_alg_in_find_is_safe<_Iter, _Ty1> // can search for the value
+                                             && sizeof(_Iter_value_t<_Iter>) >= 4; // avx masked op compatible size
+
+// Can we activate the vector algorithms for ranges::replace?
+template <class _Iter, class _Ty1, class _Ty2>
+constexpr bool _Vector_alg_in_ranges_replace_is_safe =
+    _Vector_alg_in_replace_is_safe<_Iter, _Ty1> // can search and replace
+    && _Vector_alg_in_find_is_safe_elem<_Ty2, _Iter_value_t<_Iter>>; // replacement fits
 _STD_END
 #endif // _USE_STD_VECTOR_ALGORITHMS
 
@@ -3828,6 +3863,22 @@ _CONSTEXPR20 void replace(const _FwdIt _First, const _FwdIt _Last, const _Ty& _O
     _STD _Adl_verify_range(_First, _Last);
     auto _UFirst      = _STD _Get_unwrapped(_First);
     const auto _ULast = _STD _Get_unwrapped(_Last);
+
+#if _USE_STD_VECTOR_ALGORITHMS
+    if constexpr (_Vector_alg_in_replace_is_safe<decltype(_UFirst), _Ty>) {
+#if _HAS_CXX20
+        if (!_STD is_constant_evaluated())
+#endif // _HAS_CXX20
+        {
+            if (_STD _Could_compare_equal_to_value_type<decltype(_UFirst)>(_Oldval)) {
+                _STD _Replace_vectorized(_STD _To_address(_UFirst), _STD _To_address(_ULast), _Oldval, _Newval);
+            }
+
+            return;
+        }
+    }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
     for (; _UFirst != _ULast; ++_UFirst) {
         if (*_UFirst == _Oldval) {
             *_UFirst = _Newval;
@@ -3881,6 +3932,23 @@ namespace ranges {
             _STL_INTERNAL_STATIC_ASSERT(indirectly_writable<_It, const _Ty2&>);
             _STL_INTERNAL_STATIC_ASSERT(indirect_binary_predicate<ranges::equal_to, projected<_It, _Pj>, const _Ty1*>);
 
+#if _USE_STD_VECTOR_ALGORITHMS
+            if constexpr (is_same_v<_Pj, identity> && sized_sentinel_for<_Se, _It>
+                          && _Vector_alg_in_ranges_replace_is_safe<_It, _Ty1, _Ty2>) {
+                if (!_STD is_constant_evaluated()) {
+                    const auto _Count = _Last - _First;
+
+                    if (_STD _Could_compare_equal_to_value_type<_It>(_Oldval)) {
+                        const auto _First_ptr = _STD to_address(_First);
+                        const auto _Last_ptr  = _First_ptr + _Count;
+                        _STD _Replace_vectorized(_First_ptr, _Last_ptr, _Oldval, _Newval);
+                    }
+
+                    return _First + _Count;
+                }
+            }
+#endif // _USE_STD_VECTOR_ALGORITHMS
+
             for (; _First != _Last; ++_First) {
                 if (_STD invoke(_Proj, *_First) == _Oldval) {
                     *_First = _Newval;
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 119ff45f23d..7deba10afd4 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -5850,30 +5850,34 @@ struct _Vector_alg_in_find_is_safe_object_pointers<_Ty1*, _Ty2*>
           // either _Ty1 is the same as _Ty2 (ignoring cv-qualifiers), or one of the two is void
           disjunction<is_same<remove_cv_t<_Ty1>, remove_cv_t<_Ty2>>, is_void<_Ty1>, is_void<_Ty2>>> {};
 
+// Can we activate the vector algorithms to find a value in a range of elements?
+template <class _Ty, class _Elem>
+constexpr bool _Vector_alg_in_find_is_safe_elem = disjunction_v<
+#ifdef __cpp_lib_byte
+    // We're finding a std::byte in a range of std::byte.
+    conjunction<is_same<_Ty, byte>, is_same<_Elem, byte>>,
+#endif // defined(__cpp_lib_byte)
+    // We're finding an integer in a range of integers.
+    // This case is the one that requires careful runtime handling in _Could_compare_equal_to_value_type.
+    conjunction<is_integral<_Ty>, is_integral<_Elem>>,
+    // We're finding an (object or function) pointer in a range of pointers of the same type.
+    conjunction<is_pointer<_Ty>, is_same<_Ty, _Elem>>,
+    // We're finding a nullptr in a range of (object or function) pointers.
+    conjunction<is_same<_Ty, nullptr_t>, is_pointer<_Elem>>,
+    // We're finding an object pointer in a range of object pointers, and:
+    // - One of the pointer types is a cv void*.
+    // - One of the pointer types is a cv1 U* and the other is a cv2 U*.
+    _Vector_alg_in_find_is_safe_object_pointers<_Ty, _Elem>>;
+
 // Can we activate the vector algorithms for find/count?
-template <class _Iter, class _Ty, class _Elem = _Iter_value_t<_Iter>>
-_INLINE_VAR constexpr bool _Vector_alg_in_find_is_safe =
+template <class _Iter, class _Ty>
+constexpr bool _Vector_alg_in_find_is_safe =
     // The iterator must be contiguous so we can get raw pointers.
     _Iterator_is_contiguous<_Iter>
     // The iterator must not be volatile.
     && !_Iterator_is_volatile<_Iter>
-    // And one of the following conditions must be met:
-    && disjunction_v<
-#ifdef __cpp_lib_byte
-        // We're finding a std::byte in a range of std::byte.
-        conjunction<is_same<_Ty, byte>, is_same<_Elem, byte>>,
-#endif // defined(__cpp_lib_byte)
-       // We're finding an integer in a range of integers.
-       // This case is the one that requires careful runtime handling in _Could_compare_equal_to_value_type.
-        conjunction<is_integral<_Ty>, is_integral<_Elem>>,
-        // We're finding an (object or function) pointer in a range of pointers of the same type.
-        conjunction<is_pointer<_Ty>, is_same<_Ty, _Elem>>,
-        // We're finding a nullptr in a range of (object or function) pointers.
-        conjunction<is_same<_Ty, nullptr_t>, is_pointer<_Elem>>,
-        // We're finding an object pointer in a range of object pointers, and:
-        // - One of the pointer types is a cv void*.
-        // - One of the pointer types is a cv1 U* and the other is a cv2 U*.
-        _Vector_alg_in_find_is_safe_object_pointers<_Ty, _Elem>>;
+    // The type of the value to find must be compatible with the type of the elements.
+    && _Vector_alg_in_find_is_safe_elem<_Ty, _Iter_value_t<_Iter>>;
 
 template <class _InIt, class _Ty>
 _NODISCARD constexpr bool _Could_compare_equal_to_value_type(const _Ty& _Val) {
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index 21c0a4c30e2..8f63bee1db9 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -2248,6 +2248,83 @@ __declspec(noalias) size_t
     return __std_mismatch_impl<_Find_traits_8, uint64_t>(_First1, _First2, _Count);
 }
 
+__declspec(noalias) void __stdcall __std_replace_4(
+    void* _First, void* const _Last, const uint32_t _Old_val, const uint32_t _New_val) noexcept {
+#ifndef _M_ARM64EC
+    if (_Use_avx2()) {
+        const __m256i _Comparand   = _mm256_broadcastd_epi32(_mm_cvtsi32_si128(_Old_val));
+        const __m256i _Replacement = _mm256_broadcastd_epi32(_mm_cvtsi32_si128(_New_val));
+        const size_t _Full_length  = _Byte_length(_First, _Last);
+
+        void* _Stop_at = _First;
+        _Advance_bytes(_Stop_at, _Full_length & ~size_t{0x1F});
+
+        while (_First != _Stop_at) {
+            const __m256i _Data = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First));
+            const __m256i _Mask = _mm256_cmpeq_epi32(_Comparand, _Data);
+            _mm256_maskstore_epi32(reinterpret_cast<int*>(_First), _Mask, _Replacement);
+
+            _Advance_bytes(_First, 32);
+        }
+
+        if (const size_t _Tail_length = _Full_length & 0x1C; _Tail_length != 0) {
+            const __m256i _Tail_mask = _Avx2_tail_mask_32(_Tail_length >> 2);
+            const __m256i _Data      = _mm256_maskload_epi32(reinterpret_cast<const int*>(_First), _Tail_mask);
+            const __m256i _Mask      = _mm256_and_si256(_mm256_cmpeq_epi32(_Comparand, _Data), _Tail_mask);
+            _mm256_maskstore_epi32(reinterpret_cast<int*>(_First), _Mask, _Replacement);
+        }
+    } else
+#endif // !defined(_M_ARM64EC)
+    {
+        for (auto _Cur = reinterpret_cast<uint32_t*>(_First); _Cur != _Last; ++_Cur) {
+            if (*_Cur == _Old_val) {
+                *_Cur = _New_val;
+            }
+        }
+    }
+}
+
+__declspec(noalias) void __stdcall __std_replace_8(
+    void* _First, void* const _Last, const uint64_t _Old_val, const uint64_t _New_val) noexcept {
+#ifndef _M_ARM64EC
+    if (_Use_avx2()) {
+#ifdef _WIN64
+        const __m256i _Comparand   = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(_Old_val));
+        const __m256i _Replacement = _mm256_broadcastq_epi64(_mm_cvtsi64_si128(_New_val));
+#else // ^^^ defined(_WIN64) / !defined(_WIN64), workaround, _mm_cvtsi64_si128 does not compile vvv
+        const __m256i _Comparand   = _mm256_set1_epi64x(_Old_val);
+        const __m256i _Replacement = _mm256_set1_epi64x(_New_val);
+#endif // ^^^ !defined(_WIN64) ^^^
+        const size_t _Full_length = _Byte_length(_First, _Last);
+
+        void* _Stop_at = _First;
+        _Advance_bytes(_Stop_at, _Full_length & ~size_t{0x1F});
+
+        while (_First != _Stop_at) {
+            const __m256i _Data = _mm256_loadu_si256(reinterpret_cast<const __m256i*>(_First));
+            const __m256i _Mask = _mm256_cmpeq_epi64(_Comparand, _Data);
+            _mm256_maskstore_epi64(reinterpret_cast<long long*>(_First), _Mask, _Replacement);
+
+            _Advance_bytes(_First, 32);
+        }
+
+        if (const size_t _Tail_length = _Full_length & 0x18; _Tail_length != 0) {
+            const __m256i _Tail_mask = _Avx2_tail_mask_32(_Tail_length >> 2);
+            const __m256i _Data      = _mm256_maskload_epi64(reinterpret_cast<const long long*>(_First), _Tail_mask);
+            const __m256i _Mask      = _mm256_and_si256(_mm256_cmpeq_epi64(_Comparand, _Data), _Tail_mask);
+            _mm256_maskstore_epi64(reinterpret_cast<long long*>(_First), _Mask, _Replacement);
+        }
+    } else
+#endif // !defined(_M_ARM64EC)
+    {
+        for (auto _Cur = reinterpret_cast<uint64_t*>(_First); _Cur != _Last; ++_Cur) {
+            if (*_Cur == _Old_val) {
+                *_Cur = _New_val;
+            }
+        }
+    }
+}
+
 } // extern "C"
 
 #ifndef _M_ARM64EC
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
index e263e59d628..39eed458ad3 100644
--- a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
+++ b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
@@ -536,6 +536,52 @@ namespace test_mismatch_sizes_and_alignments {
     }
 } // namespace test_mismatch_sizes_and_alignments
 
+template <class FwdIt, class T>
+void last_known_good_replace(FwdIt first, FwdIt last, const T old_val, const T new_val) {
+    for (; first != last; ++first) {
+        if (*first == old_val) {
+            *first = new_val;
+        }
+    }
+}
+
+template <class T>
+void test_case_replace(const vector<T>& input, T old_val, T new_val) {
+    vector<T> replaced_actual(input);
+    vector<T> replaced_expected(input);
+    replace(replaced_actual.begin(), replaced_actual.end(), old_val, new_val);
+    last_known_good_replace(replaced_expected.begin(), replaced_expected.end(), old_val, new_val);
+    assert(replaced_expected == replaced_actual);
+
+#if _HAS_CXX20
+    vector<T> replaced_actual_r(input);
+    ranges::replace(replaced_actual_r, old_val, new_val);
+    assert(replaced_expected == replaced_actual_r);
+#endif // _HAS_CXX20
+}
+
+template <class T>
+void test_replace(mt19937_64& gen) {
+    using TD = conditional_t<sizeof(T) == 1, int, T>;
+    uniform_int_distribution<TD> dis(0, 9);
+    vector<T> input;
+
+    input.reserve(dataCount);
+
+    {
+        const T old_val = static_cast<T>(dis(gen));
+        const T new_val = static_cast<T>(dis(gen));
+        test_case_replace(input, old_val, new_val);
+    }
+
+    for (size_t i = 0; i != dataCount; ++i) {
+        input.push_back(static_cast<T>(dis(gen)));
+        const T old_val = static_cast<T>(dis(gen));
+        const T new_val = static_cast<T>(dis(gen));
+        test_case_replace(input, old_val, new_val);
+    }
+}
+
 template <class BidIt>
 void last_known_good_reverse(BidIt first, BidIt last) {
     for (; first != last && first != --last; ++first) {
@@ -728,6 +774,12 @@ void test_vector_algorithms(mt19937_64& gen) {
     test_mismatch_sizes_and_alignments::test<int>();
     test_mismatch_sizes_and_alignments::test<long long>();
 
+    // replace() is vectorized for 4 and 8 bytes only.
+    test_replace<int>(gen);
+    test_replace<unsigned int>(gen);
+    test_replace<long long>(gen);
+    test_replace<unsigned long long>(gen);
+
     test_reverse<char>(gen);
     test_reverse<signed char>(gen);
     test_reverse<unsigned char>(gen);

From d872543747fb6d38e02a0fbab72b0948f5e9f262 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Wojciech=20Nowocie=C5=84?= <wojciech2008.nn@gmail.com>
Date: Wed, 10 Apr 2024 00:13:05 +0200
Subject: [PATCH 34/45] Update _MSVC_STL_UPDATE to April 2024 (#4556)

---
 stl/inc/yvals_core.h | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index 678341f07e9..cc016cbe848 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -886,7 +886,7 @@
 
 #define _CPPLIB_VER       650
 #define _MSVC_STL_VERSION 143
-#define _MSVC_STL_UPDATE  202403L
+#define _MSVC_STL_UPDATE  202404L
 
 #ifndef _ALLOW_COMPILER_AND_STL_VERSION_MISMATCH
 #if defined(__CUDACC__) && defined(__CUDACC_VER_MAJOR__)

From 5ced5d2e0c2c6afbf13b2337abc9e383f7183d89 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 10 Apr 2024 01:26:10 +0300
Subject: [PATCH 35/45] vectorize `find_first_of` for long needle (#4557)

---
 stl/src/vector_algorithms.cpp                 | 142 ++++++++++++++----
 .../VSO_0000000_vector_algorithms/test.cpp    |   2 +-
 2 files changed, 116 insertions(+), 28 deletions(-)

diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index 8f63bee1db9..0eb3c4cf24d 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -1997,50 +1997,138 @@ namespace {
     const void* __stdcall __std_find_first_of_trivial_impl(
         const void* _First1, const void* const _Last1, const void* const _First2, const void* const _Last2) noexcept {
 #ifndef _M_ARM64EC
-        const size_t _Needle_length = _Byte_length(_First2, _Last2);
-
-        if (_Use_sse42() && _Needle_length <= 16) {
+        if (_Use_sse42()) {
             constexpr int _Op =
                 (sizeof(_Ty) == 1 ? _SIDD_UBYTE_OPS : _SIDD_UWORD_OPS) | _SIDD_CMP_EQUAL_ANY | _SIDD_LEAST_SIGNIFICANT;
             constexpr int _Part_size_el = sizeof(_Ty) == 1 ? 16 : 8;
+            const size_t _Needle_length = _Byte_length(_First2, _Last2);
+
+            if (_Needle_length <= 16) {
+                // Special handling of small needle
+                // The generic branch could also handle it but with slightly worse performance
+
+                const int _Needle_length_el = static_cast<int>(_Needle_length / sizeof(_Ty));
+
+                alignas(16) uint8_t _Tmp1[16];
+                memcpy(_Tmp1, _First2, _Needle_length);
+                const __m128i _Needle = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+
+                const size_t _Haystack_length = _Byte_length(_First1, _Last1);
+                const void* _Stop_at          = _First1;
+                _Advance_bytes(_Stop_at, _Haystack_length & ~size_t{0xF});
 
-            const int _Needle_length_el = static_cast<int>(_Needle_length / sizeof(_Ty));
+                while (_First1 != _Stop_at) {
+                    const __m128i _Haystack_part = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+                    if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op)) {
+                        const int _Pos = _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op);
+                        _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                        return _First1;
+                    }
 
-            alignas(16) uint8_t _Tmp1[16];
-            memcpy(_Tmp1, _First2, _Needle_length);
-            const __m128i _Needle = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+                    _Advance_bytes(_First1, 16);
+                }
 
-            const size_t _Haystack_length = _Byte_length(_First1, _Last1);
-            const void* _Stop_at          = _First1;
-            _Advance_bytes(_Stop_at, _Haystack_length & ~size_t{0xF});
+                const size_t _Last_part_size = _Haystack_length & 0xF;
+                const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
 
-            while (_First1 != _Stop_at) {
-                const __m128i _Haystack_part = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+                alignas(16) uint8_t _Tmp2[16];
+                memcpy(_Tmp2, _First1, _Last_part_size);
+                const __m128i _Haystack_part = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
 
-                if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op)) {
-                    const int _Pos = _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op);
+                if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_part, _Last_part_size_el, _Op)) {
+                    const int _Pos = _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_part, _Last_part_size_el, _Op);
                     _Advance_bytes(_First1, _Pos * sizeof(_Ty));
                     return _First1;
                 }
 
-                _Advance_bytes(_First1, 16);
-            }
+                _Advance_bytes(_First1, _Last_part_size);
+                return _First1;
+            } else {
+                const void* _Last_needle = _First2;
+                _Advance_bytes(_Last_needle, _Needle_length & ~size_t{0xF});
 
-            const size_t _Last_part_size = _Haystack_length & 0xF;
-            const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+                const int _Last_needle_length = static_cast<int>(_Needle_length & 0xF);
 
-            alignas(16) uint8_t _Tmp2[16];
-            memcpy(_Tmp2, _First1, _Last_part_size);
-            const __m128i _Haystack_last_part = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+                alignas(16) uint8_t _Tmp1[16];
+                memcpy(_Tmp1, _Last_needle, _Last_needle_length);
+                const __m128i _Last_needle_val   = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp1));
+                const int _Last_needle_length_el = _Last_needle_length / sizeof(_Ty);
 
-            if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_last_part, _Last_part_size_el, _Op)) {
-                const int _Pos = _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_last_part, _Last_part_size_el, _Op);
-                _Advance_bytes(_First1, _Pos * sizeof(_Ty));
+                constexpr int _Not_found = 16; // arbitrary value greater than any found value
+
+                int _Found_pos = _Not_found;
+
+                const size_t _Haystack_length = _Byte_length(_First1, _Last1);
+                const void* _Stop_at          = _First1;
+                _Advance_bytes(_Stop_at, _Haystack_length & ~size_t{0xF});
+
+                while (_First1 != _Stop_at) {
+                    const __m128i _Haystack_part = _mm_loadu_si128(static_cast<const __m128i*>(_First1));
+
+                    for (const void* _Cur_needle = _First2; _Cur_needle != _Last_needle;
+                         _Advance_bytes(_Cur_needle, 16)) {
+                        const __m128i _Needle = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+                        if (_mm_cmpestrc(_Needle, _Part_size_el, _Haystack_part, _Part_size_el, _Op)) {
+                            const int _Pos = _mm_cmpestri(_Needle, _Part_size_el, _Haystack_part, _Part_size_el, _Op);
+                            if (_Pos < _Found_pos) {
+                                _Found_pos = _Pos;
+                            }
+                        }
+                    }
+
+                    if (const int _Needle_length_el = _Last_needle_length_el; _Needle_length_el != 0) {
+                        const __m128i _Needle = _Last_needle_val;
+                        if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op)) {
+                            const int _Pos =
+                                _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_part, _Part_size_el, _Op);
+                            if (_Pos < _Found_pos) {
+                                _Found_pos = _Pos;
+                            }
+                        }
+                    }
+
+                    if (_Found_pos != _Not_found) {
+                        _Advance_bytes(_First1, _Found_pos * sizeof(_Ty));
+                        return _First1;
+                    }
+
+                    _Advance_bytes(_First1, 16);
+                }
+
+                const size_t _Last_part_size = _Haystack_length & 0xF;
+                const int _Last_part_size_el = static_cast<int>(_Last_part_size / sizeof(_Ty));
+
+                alignas(16) uint8_t _Tmp2[16];
+                memcpy(_Tmp2, _First1, _Last_part_size);
+                const __m128i _Haystack_part = _mm_load_si128(reinterpret_cast<const __m128i*>(_Tmp2));
+
+                _Found_pos = _Last_part_size_el;
+
+                for (const void* _Cur_needle = _First2; _Cur_needle != _Last_needle; _Advance_bytes(_Cur_needle, 16)) {
+                    const __m128i _Needle = _mm_loadu_si128(static_cast<const __m128i*>(_Cur_needle));
+
+                    if (_mm_cmpestrc(_Needle, _Part_size_el, _Haystack_part, _Last_part_size_el, _Op)) {
+                        const int _Pos = _mm_cmpestri(_Needle, _Part_size_el, _Haystack_part, _Last_part_size_el, _Op);
+                        if (_Pos < _Found_pos) {
+                            _Found_pos = _Pos;
+                        }
+                    }
+                }
+
+                if (const int _Needle_length_el = _Last_needle_length_el; _Needle_length_el != 0) {
+                    const __m128i _Needle = _Last_needle_val;
+                    if (_mm_cmpestrc(_Needle, _Needle_length_el, _Haystack_part, _Last_part_size_el, _Op)) {
+                        const int _Pos =
+                            _mm_cmpestri(_Needle, _Needle_length_el, _Haystack_part, _Last_part_size_el, _Op);
+                        if (_Pos < _Found_pos) {
+                            _Found_pos = _Pos;
+                        }
+                    }
+                }
+
+                _Advance_bytes(_First1, _Found_pos * sizeof(_Ty));
                 return _First1;
             }
-
-            _Advance_bytes(_First1, _Last_part_size);
-            return _First1;
         }
 #endif // !_M_ARM64EC
 
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
index 39eed458ad3..49fec16ea07 100644
--- a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
+++ b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
@@ -238,7 +238,7 @@ void test_case_find_first_of(const vector<T>& input_haystack, const vector<T>& i
 
 template <class T>
 void test_find_first_of(mt19937_64& gen) {
-    constexpr size_t needleDataCount = 30;
+    constexpr size_t needleDataCount = 50;
     using TD                         = conditional_t<sizeof(T) == 1, int, T>;
     uniform_int_distribution<TD> dis('a', 'z');
     vector<T> input_haystack;

From 51b1a07a51ecd06f9e3061aab66dd565b25807b1 Mon Sep 17 00:00:00 2001
From: Jakub Mazurkiewicz <mazkuba3@gmail.com>
Date: Wed, 10 Apr 2024 00:33:17 +0200
Subject: [PATCH 36/45] `<mdspan>`: Throughput improvements (#4559)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/mdspan                            | 41 ++++++++++++-----------
 tests/std/include/test_mdspan_support.hpp |  2 +-
 2 files changed, 23 insertions(+), 20 deletions(-)

diff --git a/stl/inc/mdspan b/stl/inc/mdspan
index 551f60b4931..b6ba7e51c14 100644
--- a/stl/inc/mdspan
+++ b/stl/inc/mdspan
@@ -218,8 +218,8 @@ public:
         : extents(_Other, make_index_sequence<rank_dynamic()>{}) {}
 
     template <class... _OtherIndexTypes>
-        requires (is_convertible_v<_OtherIndexTypes, index_type> && ...)
-              && (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...)
+        requires conjunction_v<is_convertible<_OtherIndexTypes, index_type>...,
+                     is_nothrow_constructible<index_type, _OtherIndexTypes>...>
               && (sizeof...(_OtherIndexTypes) == rank_dynamic() || sizeof...(_OtherIndexTypes) == rank())
     constexpr explicit extents(_OtherIndexTypes... _Exts) noexcept
         : extents(_Extents_from_tuple{}, _STD tie(_Exts...), make_index_sequence<rank_dynamic()>{}) {
@@ -305,7 +305,7 @@ public:
     template <size_t... _Seq, class... _IndexTypes>
     _NODISCARD constexpr bool _Contains_multidimensional_index(
         index_sequence<_Seq...>, _IndexTypes... _Indices) const noexcept {
-        _STL_INTERNAL_STATIC_ASSERT((same_as<_IndexTypes, index_type> && ...));
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
         if constexpr (unsigned_integral<index_type>) {
             return ((_Indices < extent(_Seq)) && ...);
         } else {
@@ -318,7 +318,7 @@ template <class>
 constexpr size_t _Repeat_dynamic_extent = dynamic_extent;
 
 template <class... _Integrals>
-    requires (is_convertible_v<_Integrals, size_t> && ...)
+    requires conjunction_v<is_convertible<_Integrals, size_t>...>
 explicit extents(_Integrals...) -> extents<size_t, _Repeat_dynamic_extent<_Integrals>...>;
 
 template <class _IndexType, class _Indices>
@@ -561,8 +561,9 @@ public:
     }
 
     template <class... _IndexTypes>
-        requires (sizeof...(_IndexTypes) == extents_type::rank()) && (is_convertible_v<_IndexTypes, index_type> && ...)
-              && (is_nothrow_constructible_v<index_type, _IndexTypes> && ...)
+        requires (sizeof...(_IndexTypes) == extents_type::rank())
+              && conjunction_v<is_convertible<_IndexTypes, index_type>...,
+                  is_nothrow_constructible<index_type, _IndexTypes>...>
     _NODISCARD constexpr index_type operator()(_IndexTypes... _Indices) const noexcept {
         return _Index_impl(make_index_sequence<extents_type::rank()>{}, static_cast<index_type>(_Indices)...);
     }
@@ -611,7 +612,7 @@ private:
     template <class... _IndexTypes, size_t... _Seq>
     _NODISCARD constexpr index_type _Index_impl(
         [[maybe_unused]] index_sequence<_Seq...> _Index_seq, _IndexTypes... _Indices) const noexcept {
-        _STL_INTERNAL_STATIC_ASSERT((same_as<_IndexTypes, index_type> && ...));
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
 #if _CONTAINER_DEBUG_LEVEL > 0
         _STL_VERIFY(this->_Exts._Contains_multidimensional_index(_Index_seq, _Indices...),
             "Value of extents_type::index-cast(i) must be a multidimensional index in extents_ (N4950 "
@@ -713,8 +714,9 @@ public:
     }
 
     template <class... _IndexTypes>
-        requires (sizeof...(_IndexTypes) == extents_type::rank()) && (is_convertible_v<_IndexTypes, index_type> && ...)
-              && (is_nothrow_constructible_v<index_type, _IndexTypes> && ...)
+        requires (sizeof...(_IndexTypes) == extents_type::rank())
+              && conjunction_v<is_convertible<_IndexTypes, index_type>...,
+                  is_nothrow_constructible<index_type, _IndexTypes>...>
     _NODISCARD constexpr index_type operator()(_IndexTypes... _Indices) const noexcept {
         return _Index_impl(make_index_sequence<extents_type::rank()>{}, static_cast<index_type>(_Indices)...);
     }
@@ -763,7 +765,7 @@ private:
     template <class... _IndexTypes, size_t... _Seq>
     _NODISCARD constexpr index_type _Index_impl(
         [[maybe_unused]] index_sequence<_Seq...> _Index_seq, _IndexTypes... _Indices) const noexcept {
-        _STL_INTERNAL_STATIC_ASSERT((same_as<_IndexTypes, index_type> && ...));
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
 #if _CONTAINER_DEBUG_LEVEL > 0
         _STL_VERIFY(this->_Exts._Contains_multidimensional_index(_Index_seq, _Indices...),
             "Value of extents_type::index-cast(i) must be a multidimensional index in extents_ (N4950 "
@@ -938,8 +940,9 @@ public:
     }
 
     template <class... _IndexTypes>
-        requires (sizeof...(_IndexTypes) == extents_type::rank()) && (is_convertible_v<_IndexTypes, index_type> && ...)
-              && (is_nothrow_constructible_v<index_type, _IndexTypes> && ...)
+        requires (sizeof...(_IndexTypes) == extents_type::rank())
+              && conjunction_v<is_convertible<_IndexTypes, index_type>...,
+                  is_nothrow_constructible<index_type, _IndexTypes>...>
     _NODISCARD constexpr index_type operator()(_IndexTypes... _Indices) const noexcept {
         return _Index_impl(make_index_sequence<extents_type::rank()>{}, static_cast<index_type>(_Indices)...);
     }
@@ -1020,7 +1023,7 @@ private:
     template <class... _IndexTypes, size_t... _Seq>
     _NODISCARD constexpr index_type _Index_impl(
         [[maybe_unused]] index_sequence<_Seq...> _Index_seq, _IndexTypes... _Indices) const noexcept {
-        _STL_INTERNAL_STATIC_ASSERT((same_as<_IndexTypes, index_type> && ...));
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_IndexTypes, index_type>...>);
 #if _CONTAINER_DEBUG_LEVEL > 0
         _STL_VERIFY(this->_Exts._Contains_multidimensional_index(_Index_seq, _Indices...),
             "Value of extents_type::index-cast(i) must be a multidimensional index in extents_ (N4950 "
@@ -1215,8 +1218,8 @@ public:
     constexpr mdspan(mdspan&&)      = default;
 
     template <class... _OtherIndexTypes>
-        requires (is_convertible_v<_OtherIndexTypes, index_type> && ...)
-                  && (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...)
+        requires conjunction_v<is_convertible<_OtherIndexTypes, index_type>...,
+                     is_nothrow_constructible<index_type, _OtherIndexTypes>...>
                   && (sizeof...(_OtherIndexTypes) == rank() || sizeof...(_OtherIndexTypes) == rank_dynamic())
                   && is_constructible_v<mapping_type, extents_type> && is_default_constructible_v<accessor_type>
     constexpr explicit mdspan(data_handle_type _Ptr_, _OtherIndexTypes... _Exts) noexcept(
@@ -1295,8 +1298,8 @@ public:
 
 #ifdef __cpp_multidimensional_subscript // TRANSITION, P2128R6
     template <class... _OtherIndexTypes>
-        requires (is_convertible_v<_OtherIndexTypes, index_type> && ...)
-              && (is_nothrow_constructible_v<index_type, _OtherIndexTypes> && ...)
+        requires conjunction_v<is_convertible<_OtherIndexTypes, index_type>...,
+                     is_nothrow_constructible<index_type, _OtherIndexTypes>...>
               && (sizeof...(_OtherIndexTypes) == rank())
     _NODISCARD constexpr reference operator[](_OtherIndexTypes... _Indices) const
         noexcept(noexcept(_Access_impl(static_cast<index_type>(_STD move(_Indices))...))) /* strengthened */ {
@@ -1427,7 +1430,7 @@ private:
     template <class... _OtherIndexTypes>
     _NODISCARD constexpr reference _Access_impl(_OtherIndexTypes... _Indices) const
         noexcept(noexcept(this->_Acc.access(_Ptr, static_cast<size_t>(this->_Map(_Indices...))))) {
-        _STL_INTERNAL_STATIC_ASSERT((same_as<_OtherIndexTypes, index_type> && ...));
+        _STL_INTERNAL_STATIC_ASSERT(conjunction_v<is_same<_OtherIndexTypes, index_type>...>);
 #if _CONTAINER_DEBUG_LEVEL > 0
         _STL_VERIFY(this->_Map.extents()._Contains_multidimensional_index(make_index_sequence<rank()>{}, _Indices...),
             "I must be a multidimensional index in extents() (N4950 [mdspan.mdspan.members]/3).");
@@ -1448,7 +1451,7 @@ template <class _Pointer>
 mdspan(_Pointer&&) -> mdspan<remove_pointer_t<remove_reference_t<_Pointer>>, extents<size_t>>;
 
 template <class _ElementType, class... _Integrals>
-    requires ((is_convertible_v<_Integrals, size_t> && ...) && sizeof...(_Integrals) > 0)
+    requires conjunction_v<is_convertible<_Integrals, size_t>...> && (sizeof...(_Integrals) > 0)
 explicit mdspan(_ElementType*, _Integrals...) -> mdspan<_ElementType, dextents<size_t, sizeof...(_Integrals)>>;
 
 template <class _ElementType, class _OtherIndexType, size_t _Nx>
diff --git a/tests/std/include/test_mdspan_support.hpp b/tests/std/include/test_mdspan_support.hpp
index b9d4a0acf84..cc09948b0ab 100644
--- a/tests/std/include/test_mdspan_support.hpp
+++ b/tests/std/include/test_mdspan_support.hpp
@@ -256,7 +256,7 @@ MappingProperties<Mapping> get_mapping_properties(const Mapping& mapping) {
         return std::views::cartesian_product(std::views::iota(IndexType{0}, get_extent(Indices))...);
     }(rank_indices);
 
-    auto map_index      = [&](const auto& tpl) { return std::apply([&](auto... i) { return mapping(i...); }, tpl); };
+    auto map_index      = [&](const auto& tpl) { return std::apply(mapping, tpl); };
     auto mapped_indices = multidim_indices | std::views::transform(map_index) | std::ranges::to<std::vector>();
     std::ranges::sort(mapped_indices);
 

From d0995ffb4a76269ccb2f51ce676192f9bf2eaaee Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 10 Apr 2024 01:38:03 +0300
Subject: [PATCH 37/45] Check if `find_last` can find anything (#4561)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/algorithm                             |   7 +-
 .../env.lst                                   |   3 +
 .../test.cpp                                  | 231 +++++++++++++++++-
 3 files changed, 237 insertions(+), 4 deletions(-)

diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 761031054d1..9f970243a91 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -3028,7 +3028,12 @@ namespace ranges {
             if constexpr (is_same_v<_Pj, identity> && _Vector_alg_in_find_is_safe<_It, _Ty>
                           && sized_sentinel_for<_Se, _It>) {
                 if (!_STD is_constant_evaluated()) {
-                    const auto _Count     = _Last - _First;
+                    const auto _Count = _Last - _First;
+
+                    if (!_STD _Could_compare_equal_to_value_type<_It>(_Value)) {
+                        return {_First + _Count, _First + _Count};
+                    }
+
                     const auto _First_ptr = _STD _To_address(_First);
                     const auto _Last_ptr  = _First_ptr + _Count;
 
diff --git a/tests/std/tests/Dev11_0316853_find_memchr_optimization/env.lst b/tests/std/tests/Dev11_0316853_find_memchr_optimization/env.lst
index 19f025bd0e6..78fbe6b49a4 100644
--- a/tests/std/tests/Dev11_0316853_find_memchr_optimization/env.lst
+++ b/tests/std/tests/Dev11_0316853_find_memchr_optimization/env.lst
@@ -2,3 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 RUNALL_INCLUDE ..\usual_matrix.lst
+RUNALL_CROSSLIST
+*	PM_CL=""
+*	PM_CL="/D_USE_STD_VECTOR_ALGORITHMS=0"
diff --git a/tests/std/tests/Dev11_0316853_find_memchr_optimization/test.cpp b/tests/std/tests/Dev11_0316853_find_memchr_optimization/test.cpp
index 5ec9aaf9445..4a7eb9526b6 100644
--- a/tests/std/tests/Dev11_0316853_find_memchr_optimization/test.cpp
+++ b/tests/std/tests/Dev11_0316853_find_memchr_optimization/test.cpp
@@ -55,14 +55,23 @@ void test_limit_check_elements_impl() {
         if constexpr (is_signed_v<ValueType>) {
             if constexpr (numeric_limits<ValueType>::min() < min_val) {
                 assert(find(begin(sc), end(sc), ValueType{ValueType{min_val} - 1}) == end(sc));
+#if _HAS_CXX23
+                assert(ranges::find_last(sc, ValueType{ValueType{min_val} - 1}).begin() == end(sc));
+#endif // _HAS_CXX23
             }
 
             if constexpr (sizeof(ElementType) <= sizeof(ValueType)) {
                 assert(find(begin(sc), end(sc), ValueType{min_val}) == begin(sc));
+#if _HAS_CXX23
+                assert(ranges::find_last(sc, ValueType{min_val}).begin() == begin(sc));
+#endif // _HAS_CXX23
             }
-            assert(find(begin(sc), end(sc), ValueType{-1}) == begin(sc) + 4);
 
+            assert(find(begin(sc), end(sc), ValueType{-1}) == begin(sc) + 4);
             assert(count(begin(sc), end(sc), ValueType{-1}) == 2);
+#if _HAS_CXX23
+            assert(ranges::find_last(sc, ValueType{-1}).begin() == begin(sc) + 5);
+#endif // _HAS_CXX23
         } else {
             constexpr auto max_vt = numeric_limits<ValueType>::max();
             if constexpr (ElementType{-1} == max_vt) {
@@ -72,23 +81,42 @@ void test_limit_check_elements_impl() {
 
                 assert(count(begin(sc), end(sc), max_vt) == 2);
                 assert(count(begin(sc), end(sc), max_vt - 1) == 1);
+
+#if _HAS_CXX23
+                assert(ranges::find_last(sc, max_vt).begin() == begin(sc) + 5);
+                assert(ranges::find_last(sc, max_vt - 1).begin() == begin(sc) + 3);
+#endif // _HAS_CXX23
             } else {
                 assert(find(begin(sc), end(sc), max_vt) == end(sc));
                 assert(find(begin(sc), end(sc), max_vt - 1) == end(sc));
 
                 assert(count(begin(sc), end(sc), max_vt) == 0);
                 assert(count(begin(sc), end(sc), max_vt - 1) == 0);
+
+#if _HAS_CXX23
+                assert(ranges::find_last(sc, max_vt).begin() == end(sc));
+                assert(ranges::find_last(sc, max_vt - 1).begin() == end(sc));
+#endif // _HAS_CXX23
             }
         }
 
-        assert(count(begin(sc), end(sc), ValueType{0}) == 1);
-
         assert(find(begin(sc), end(sc), ValueType{0}) == begin(sc) + 6);
         assert(find(begin(sc), end(sc), ValueType{5}) == end(sc));
 
+        assert(count(begin(sc), end(sc), ValueType{0}) == 1);
+        assert(count(begin(sc), end(sc), ValueType{5}) == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(sc, ValueType{0}).begin() == begin(sc) + 6);
+        assert(ranges::find_last(sc, ValueType{5}).begin() == end(sc));
+#endif // _HAS_CXX23
+
         if constexpr (sizeof(ElementType) <= sizeof(ValueType)) {
             assert(find(begin(sc), end(sc), ValueType{max_val}) == begin(sc) + 12);
             assert(count(begin(sc), end(sc), ValueType{max_val}) == 1);
+#if _HAS_CXX23
+            assert(ranges::find_last(sc, ValueType{max_val}).begin() == begin(sc) + 12);
+#endif // _HAS_CXX23
 
             if constexpr (sizeof(ElementType) < sizeof(ValueType)) {
                 assert(find(begin(sc), end(sc), ValueType{ValueType{max_val} + 1}) == end(sc));
@@ -96,6 +124,11 @@ void test_limit_check_elements_impl() {
 
                 assert(count(begin(sc), end(sc), ValueType{ValueType{max_val} + 1}) == 0);
                 assert(count(begin(sc), end(sc), ValueType{umax_val}) == 0);
+
+#if _HAS_CXX23
+                assert(ranges::find_last(sc, ValueType{ValueType{max_val} + 1}).begin() == end(sc));
+                assert(ranges::find_last(sc, ValueType{umax_val}).begin() == end(sc));
+#endif // _HAS_CXX23
             }
         }
     } else {
@@ -107,6 +140,11 @@ void test_limit_check_elements_impl() {
         assert(find(begin(uc), end(uc), ValueType{0}) == begin(uc));
         assert(find(begin(uc), end(uc), ValueType{2}) == begin(uc) + 3);
         assert(find(begin(uc), end(uc), ValueType{6}) == end(uc));
+#if _HAS_CXX23
+        assert(ranges::find_last(uc, ValueType{0}).begin() == begin(uc));
+        assert(ranges::find_last(uc, ValueType{2}).begin() == begin(uc) + 3);
+        assert(ranges::find_last(uc, ValueType{6}).begin() == end(uc));
+#endif // _HAS_CXX23
 
         if constexpr (is_signed_v<ValueType>) {
             if constexpr (ValueType{-1} == max_val) {
@@ -116,12 +154,20 @@ void test_limit_check_elements_impl() {
 
                 assert(count(begin(uc), end(uc), ValueType{-1}) == 1);
                 assert(count(begin(uc), end(uc), ValueType{-2}) == 1);
+#if _HAS_CXX23
+                assert(ranges::find_last(uc, ValueType{-1}).begin() == begin(uc) + 6);
+                assert(ranges::find_last(uc, ValueType{-2}).begin() == begin(uc) + 5);
+#endif // _HAS_CXX23
             } else {
                 assert(find(begin(uc), end(uc), ValueType{-1}) == end(uc));
                 assert(find(begin(uc), end(uc), ValueType{-2}) == end(uc));
 
                 assert(count(begin(uc), end(uc), ValueType{-1}) == 0);
                 assert(count(begin(uc), end(uc), ValueType{-2}) == 0);
+#if _HAS_CXX23
+                assert(ranges::find_last(uc, ValueType{-1}).begin() == end(uc));
+                assert(ranges::find_last(uc, ValueType{-2}).begin() == end(uc));
+#endif // _HAS_CXX23
             }
         }
 
@@ -129,10 +175,24 @@ void test_limit_check_elements_impl() {
             assert(find(begin(uc), end(uc), ValueType{max_val - 3}) == end(uc));
             assert(find(begin(uc), end(uc), ValueType{max_val - 2}) == begin(uc) + 4);
             assert(find(begin(uc), end(uc), ValueType{max_val}) == begin(uc) + 6);
+
+#if _HAS_CXX23
+            assert(ranges::find_last(uc, ValueType{max_val - 3}).begin() == end(uc));
+            assert(ranges::find_last(uc, ValueType{max_val - 2}).begin() == begin(uc) + 4);
+            assert(ranges::find_last(uc, ValueType{max_val}).begin() == begin(uc) + 6);
+#endif // _HAS_CXX23
+
             if constexpr (max_val < max_vt) {
                 assert(find(begin(uc), end(uc), ValueType{ValueType{max_val} + 1}) == end(uc));
+#if _HAS_CXX23
+                assert(ranges::find_last(uc, ValueType{ValueType{max_val} + 1}).begin() == end(uc));
+#endif // _HAS_CXX23
+
                 if constexpr (sizeof(ElementType) < sizeof(ValueType)) {
                     assert(find(begin(uc), end(uc), max_vt) == end(uc));
+#if _HAS_CXX23
+                    assert(ranges::find_last(uc, max_vt).begin() == end(uc));
+#endif // _HAS_CXX23
                 }
             }
         }
@@ -180,6 +240,12 @@ int main() {
         assert(count(v.cbegin(), v.cend(), 33) == 1);
         assert(count(v.cbegin(), v.cend(), 44) == 2);
         assert(count(v.cbegin(), v.cend(), 255) == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(v, 33).begin() - v.begin() == 1);
+        assert(ranges::find_last(v, -1).begin() - v.begin() == 2);
+        assert(ranges::find_last(v, 255).begin() - v.begin() == 6);
+#endif // _HAS_CXX23
     }
 
 
@@ -199,6 +265,11 @@ int main() {
 
         assert(count(l.begin(), l.end(), 44) == 2);
         assert(count(l.begin(), l.end(), 17) == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(l, 44).begin() == next(l.begin(), 4));
+        assert(ranges::find_last(l, 17).begin() == l.end());
+#endif // _HAS_CXX23
     }
 
     { // Optimization inapplicable due to bogus element type and bogus value type
@@ -215,6 +286,11 @@ int main() {
 
         assert(count(v.begin(), v.end(), "cute") == 2);
         assert(count(v.begin(), v.end(), "zombies") == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(v, "fluffy").begin() == v.begin() + 2);
+        assert(ranges::find_last(v, "zombies").begin() == v.end());
+#endif // _HAS_CXX23
     }
 
     {
@@ -237,6 +313,11 @@ int main() {
 
         assert(count(v.begin(), v.end(), 0xAABBCCDDUL) == 1);
         assert(count(v.begin(), v.end(), 0x11UL) == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(v, 0xAABBCCDDUL).begin() == v.begin() + 2);
+        assert(ranges::find_last(v, 0x11UL).begin() == v.end());
+#endif // _HAS_CXX23
     }
 
     { // Optimization inapplicable due to bogus value type (although the element type is good)
@@ -280,6 +361,11 @@ int main() {
 
         assert(count(vc.cbegin(), vc.cend(), 'o') == 2);
         assert(count(vc.cbegin(), vc.cend(), 'X') == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(vc, 'o').begin() == vc.begin() + 4);
+        assert(ranges::find_last(vc, 'X').begin() == vc.end());
+#endif // _HAS_CXX23
     }
 
     { // Test optimized element types.
@@ -307,6 +393,15 @@ int main() {
         assert(find(vsc.cbegin(), vsc.cend(), -128) == vsc.cbegin() + 3);
         assert(find(vsc.cbegin(), vsc.cend(), 127) == vsc.cbegin() + 4);
         assert(find(vsc.cbegin(), vsc.cend(), 255) == vsc.cend());
+
+#if _HAS_CXX23
+        assert(ranges::find_last(vsc, 17).begin() == vsc.begin());
+        assert(ranges::find_last(vsc, 29).begin() == vsc.begin() + 1);
+        assert(ranges::find_last(vsc, -1).begin() == vsc.begin() + 2);
+        assert(ranges::find_last(vsc, -128).begin() == vsc.begin() + 3);
+        assert(ranges::find_last(vsc, 127).begin() == vsc.begin() + 4);
+        assert(ranges::find_last(vsc, 255).begin() == vsc.end());
+#endif // _HAS_CXX23
     }
 
     { // Test optimized element types.
@@ -328,6 +423,12 @@ int main() {
         assert(find(vuc.cbegin(), vuc.cend(), 47) == vuc.cbegin() + 2);
         assert(find(vuc.cbegin(), vuc.cend(), 255) == vuc.cbegin() + 4);
         assert(find(vuc.cbegin(), vuc.cend(), -1) == vuc.cend());
+
+#if _HAS_CXX23
+        assert(ranges::find_last(vuc, 47).begin() == vuc.begin() + 2);
+        assert(ranges::find_last(vuc, 255).begin() == vuc.begin() + 4);
+        assert(ranges::find_last(vuc, -1).begin() == vuc.end());
+#endif // _HAS_CXX23
     }
 
 
@@ -353,6 +454,26 @@ int main() {
 
         assert(find(begin(arr), end(arr), false) == begin(arr) + 2);
         assert(find(begin(arr), end(arr), true) == end(arr));
+
+#if _HAS_CXX23
+        assert(ranges::find_last(arr, static_cast<signed char>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<short>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<int>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<long>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<long long>(30)).begin() == begin(arr) + 4);
+
+        assert(ranges::find_last(arr, static_cast<unsigned char>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<unsigned short>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<unsigned int>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<unsigned long>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<unsigned long long>(30)).begin() == begin(arr) + 4);
+
+        assert(ranges::find_last(arr, static_cast<char>(30)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, static_cast<wchar_t>(30)).begin() == begin(arr) + 4);
+
+        assert(ranges::find_last(arr, false).begin() == begin(arr) + 2);
+        assert(ranges::find_last(arr, true).begin() == end(arr));
+#endif // _HAS_CXX23
     }
 
     // Test limit checks.
@@ -395,6 +516,26 @@ int main() {
         assert(find(begin(sc), end(sc), 0xFFFFFFFFFFFFFF7FULL) == end(sc));
         assert(find(begin(sc), end(sc), 0xFFFFFFFFFFFFFF00ULL) == end(sc));
 
+#if _HAS_CXX23
+        assert(ranges::find_last(sc, static_cast<unsigned short>(0xFFFF)).begin() == end(sc));
+
+        assert(ranges::find_last(sc, 0xFFFFFFFFUL).begin() == begin(sc) + 4);
+        assert(ranges::find_last(sc, 0xFFFFFFFEUL).begin() == begin(sc) + 3);
+        assert(ranges::find_last(sc, 0xFFFFFFAAUL).begin() == end(sc));
+        assert(ranges::find_last(sc, 0xFFFFFF81UL).begin() == begin(sc) + 1);
+        assert(ranges::find_last(sc, 0xFFFFFF80UL).begin() == begin(sc));
+        assert(ranges::find_last(sc, 0xFFFFFF7FUL).begin() == end(sc));
+        assert(ranges::find_last(sc, 0xFFFFFF00UL).begin() == end(sc));
+
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFFFFULL).begin() == begin(sc) + 4);
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFFFEULL).begin() == begin(sc) + 3);
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFFAAULL).begin() == end(sc));
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFF81ULL).begin() == begin(sc) + 1);
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFF80ULL).begin() == begin(sc));
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFF7FULL).begin() == end(sc));
+        assert(ranges::find_last(sc, 0xFFFFFFFFFFFFFF00ULL).begin() == end(sc));
+#endif // _HAS_CXX23
+
         const short ss[] = {-32768, -32767, -32766, -2, -1, 0, 1, 2, 32765, 32766, 32767};
 
         STATIC_ASSERT(static_cast<short>(-1) != static_cast<unsigned short>(0xFFFF));
@@ -421,6 +562,26 @@ int main() {
         assert(find(begin(ss), end(ss), 0xFFFFFFFFFFFF7FFFULL) == end(ss));
         assert(find(begin(ss), end(ss), 0xFFFFFFFFFFFF0000ULL) == end(ss));
 
+#if _HAS_CXX23
+        assert(ranges::find_last(ss, static_cast<unsigned short>(0xFFFF)).begin() == end(ss));
+
+        assert(ranges::find_last(ss, 0xFFFFFFFFUL).begin() == begin(ss) + 4);
+        assert(ranges::find_last(ss, 0xFFFFFFFEUL).begin() == begin(ss) + 3);
+        assert(ranges::find_last(ss, 0xFFFFAAAAUL).begin() == end(ss));
+        assert(ranges::find_last(ss, 0xFFFF8001UL).begin() == begin(ss) + 1);
+        assert(ranges::find_last(ss, 0xFFFF8000UL).begin() == begin(ss));
+        assert(ranges::find_last(ss, 0xFFFF7FFFUL).begin() == end(ss));
+        assert(ranges::find_last(ss, 0xFFFF0000UL).begin() == end(ss));
+
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFFFFFFULL).begin() == begin(ss) + 4);
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFFFFFEULL).begin() == begin(ss) + 3);
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFFAAAAULL).begin() == end(ss));
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFF8001ULL).begin() == begin(ss) + 1);
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFF8000ULL).begin() == begin(ss));
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFF7FFFULL).begin() == end(ss));
+        assert(ranges::find_last(ss, 0xFFFFFFFFFFFF0000ULL).begin() == end(ss));
+#endif // _HAS_CXX23
+
         // No longer integral promotions, still repeat the applicable part once to be sure
 
         const long sl[] = {long_min, long_min + 1, long_min + 2, -2, -1, 0, 1, 2, long_max - 2, long_max - 1, long_max};
@@ -446,6 +607,24 @@ int main() {
         assert(find(begin(sl), end(sl), 0xFFFFFFFF80000000ULL) == begin(sl));
         assert(find(begin(sl), end(sl), 0xFFFFFFFF7FFFFFFFULL) == end(sl));
         assert(find(begin(sl), end(sl), 0xFFFFFFFF00000000ULL) == end(sl));
+
+#if _HAS_CXX23
+        assert(ranges::find_last(sl, static_cast<unsigned short>(0xFFFF)).begin() == end(sl));
+
+        assert(ranges::find_last(sl, 0xFFFFFFFFUL).begin() == begin(sl) + 4);
+        assert(ranges::find_last(sl, 0xFFFFFFFEUL).begin() == begin(sl) + 3);
+        assert(ranges::find_last(sl, 0xAAAAAAAAUL).begin() == end(sl));
+        assert(ranges::find_last(sl, 0x80000001UL).begin() == begin(sl) + 1);
+        assert(ranges::find_last(sl, 0x80000000UL).begin() == begin(sl));
+
+        assert(ranges::find_last(sl, 0xFFFFFFFFFFFFFFFFULL).begin() == begin(sl) + 4);
+        assert(ranges::find_last(sl, 0xFFFFFFFFFFFFFFFEULL).begin() == begin(sl) + 3);
+        assert(ranges::find_last(sl, 0xFFFFFFFFAAAAAAAAULL).begin() == end(sl));
+        assert(ranges::find_last(sl, 0xFFFFFFFF80000001ULL).begin() == begin(sl) + 1);
+        assert(ranges::find_last(sl, 0xFFFFFFFF80000000ULL).begin() == begin(sl));
+        assert(ranges::find_last(sl, 0xFFFFFFFF7FFFFFFFULL).begin() == end(sl));
+        assert(ranges::find_last(sl, 0xFFFFFFFF00000000ULL).begin() == end(sl));
+#endif // _HAS_CXX23
     }
 
     { // unsigned int == int, weird conversions yay! (GH-3244)
@@ -456,6 +635,14 @@ int main() {
         assert(find(begin(ui), end(ui), 3) == end(ui));
         assert(find(begin(ui), end(ui), -2) == begin(ui) + 4);
         assert(find(begin(ui), end(ui), -1) == begin(ui) + 5);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(ui, 0).begin() == begin(ui));
+        assert(ranges::find_last(ui, 2).begin() == begin(ui) + 2);
+        assert(ranges::find_last(ui, 3).begin() == end(ui));
+        assert(ranges::find_last(ui, -2).begin() == begin(ui) + 4);
+        assert(ranges::find_last(ui, -1).begin() == begin(ui) + 5);
+#endif // _HAS_CXX23
     }
 
     { // Test bools
@@ -470,6 +657,12 @@ int main() {
         assert(count(begin(arr), end(arr), false) == 2);
         assert(count(begin(arr), end(arr), true) == 4);
         assert(count(begin(arr), end(arr), 2) == 0);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(arr, false).begin() == begin(arr) + 5);
+        assert(ranges::find_last(arr, true).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, 2).begin() == end(arr));
+#endif // _HAS_CXX23
     }
 
     { // Test pointers
@@ -508,6 +701,22 @@ int main() {
         assert(count(begin(arr), end(arr), static_cast<const char*>(nullptr)) == 1);
         assert(count(begin(arr), end(arr), nullptr) == 1);
 
+#if _HAS_CXX23
+        assert(ranges::find_last(arr, s).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, const_cast<char*>(s)).begin() == begin(arr) + 4);
+        assert(ranges::find_last(arr, const_cast<volatile char*>(s)).begin() == begin(arr) + 4);
+
+        assert(ranges::find_last(arr, s + 1).begin() == begin(arr) + 2);
+        assert(ranges::find_last(arr, static_cast<const void*>(s + 1)).begin() == begin(arr) + 2);
+
+        assert(ranges::find_last(arr, s + 3).begin() == end(arr));
+        assert(ranges::find_last(arr, static_cast<const void*>(s + 3)).begin() == end(arr));
+
+        assert(ranges::find_last(arr, static_cast<const char*>(nullptr)).begin() == begin(arr) + 6);
+        assert(ranges::find_last(arr, static_cast<const void*>(nullptr)).begin() == begin(arr) + 6);
+        assert(ranges::find_last(arr, nullptr).begin() == begin(arr) + 6);
+#endif // _HAS_CXX23
+
         // const void pointer range
         assert(find(begin(arr_void), end(arr_void), s) == begin(arr_void));
         assert(find(begin(arr_void), end(arr_void), const_cast<char*>(s)) == begin(arr_void));
@@ -528,6 +737,22 @@ int main() {
         assert(count(begin(arr_void), end(arr_void), s + 3) == 0);
         assert(count(begin(arr_void), end(arr_void), static_cast<const char*>(nullptr)) == 1);
         assert(count(begin(arr_void), end(arr_void), nullptr) == 1);
+
+#if _HAS_CXX23
+        assert(ranges::find_last(arr_void, s).begin() == begin(arr_void) + 4);
+        assert(ranges::find_last(arr_void, const_cast<char*>(s)).begin() == begin(arr_void) + 4);
+        assert(ranges::find_last(arr_void, const_cast<volatile char*>(s)).begin() == begin(arr_void) + 4);
+
+        assert(ranges::find_last(arr_void, s + 1).begin() == begin(arr_void) + 2);
+        assert(ranges::find_last(arr_void, static_cast<const void*>(s + 1)).begin() == begin(arr_void) + 2);
+
+        assert(ranges::find_last(arr_void, s + 3).begin() == end(arr_void));
+        assert(ranges::find_last(arr_void, static_cast<const void*>(s + 3)).begin() == end(arr_void));
+
+        assert(ranges::find_last(arr_void, static_cast<const char*>(nullptr)).begin() == begin(arr_void) + 6);
+        assert(ranges::find_last(arr_void, static_cast<const void*>(nullptr)).begin() == begin(arr_void) + 6);
+        assert(ranges::find_last(arr_void, nullptr).begin() == begin(arr_void) + 6);
+#endif // _HAS_CXX23
     }
 
     { // random other checks for _Vector_alg_in_find_is_safe

From 56ad8253a8efe3bbb5bbde42c9fd755764959f44 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Wed, 10 Apr 2024 01:45:18 +0300
Subject: [PATCH 38/45] Optimize `find_first_of` for one element needle (#4563)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/src/find_first_of.cpp | 44 +++++++++++++++++---------------
 stl/inc/algorithm                | 37 ++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 26 deletions(-)

diff --git a/benchmarks/src/find_first_of.cpp b/benchmarks/src/find_first_of.cpp
index 170793f1e58..4697ccd3c8a 100644
--- a/benchmarks/src/find_first_of.cpp
+++ b/benchmarks/src/find_first_of.cpp
@@ -5,19 +5,27 @@
 #include <benchmark/benchmark.h>
 #include <cstddef>
 #include <cstdint>
+#include <cstdlib>
 #include <numeric>
 #include <vector>
 
 using namespace std;
 
-template <class T, size_t Pos, size_t NSize, size_t HSize = Pos * 2, size_t Which = 0>
+template <class T>
 void bm(benchmark::State& state) {
+    const size_t Pos   = static_cast<size_t>(state.range(0));
+    const size_t NSize = static_cast<size_t>(state.range(1));
+    const size_t HSize = Pos * 2;
+    const size_t Which = 0;
+
     vector<T> h(HSize, T{'.'});
     vector<T> n(NSize);
     iota(n.begin(), n.end(), T{'a'});
 
-    static_assert(Pos < HSize);
-    static_assert(Which < NSize);
+    if (Pos >= HSize || Which >= NSize) {
+        abort();
+    }
+
     h[Pos] = n[Which];
 
     for (auto _ : state) {
@@ -25,22 +33,18 @@ void bm(benchmark::State& state) {
     }
 }
 
-BENCHMARK(bm<uint8_t, 2, 3>);
-BENCHMARK(bm<uint16_t, 2, 3>);
-
-BENCHMARK(bm<uint8_t, 7, 4>);
-BENCHMARK(bm<uint16_t, 7, 4>);
-
-BENCHMARK(bm<uint8_t, 9, 3>);
-BENCHMARK(bm<uint16_t, 9, 3>);
-
-BENCHMARK(bm<uint8_t, 22, 5>);
-BENCHMARK(bm<uint16_t, 22, 5>);
-
-BENCHMARK(bm<uint8_t, 3056, 7>);
-BENCHMARK(bm<uint16_t, 3056, 7>);
-
-BENCHMARK(bm<uint8_t, 1011, 11>);
-BENCHMARK(bm<uint16_t, 1011, 11>);
+#define ARGS               \
+    Args({2, 3})           \
+        ->Args({7, 4})     \
+        ->Args({9, 3})     \
+        ->Args({22, 5})    \
+        ->Args({58, 2})    \
+        ->Args({102, 4})   \
+        ->Args({325, 1})   \
+        ->Args({1011, 11}) \
+        ->Args({3056, 7});
+
+BENCHMARK(bm<uint8_t>)->ARGS;
+BENCHMARK(bm<uint16_t>)->ARGS;
 
 BENCHMARK_MAIN();
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index 9f970243a91..f4bfbd75a14 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -3440,10 +3440,26 @@ _NODISCARD _CONSTEXPR20 _FwdIt1 find_first_of(
     // look for one of [_First2, _Last2) satisfying _Pred with element
     _STD _Adl_verify_range(_First1, _Last1);
     _STD _Adl_verify_range(_First2, _Last2);
-    auto _UFirst1       = _STD _Get_unwrapped(_First1);
-    const auto _ULast1  = _STD _Get_unwrapped(_Last1);
-    const auto _UFirst2 = _STD _Get_unwrapped(_First2);
-    const auto _ULast2  = _STD _Get_unwrapped(_Last2);
+    auto _UFirst1      = _STD _Get_unwrapped(_First1);
+    auto _ULast1       = _STD _Get_unwrapped(_Last1);
+    auto _UFirst2      = _STD _Get_unwrapped(_First2);
+    const auto _ULast2 = _STD _Get_unwrapped(_Last2);
+
+    constexpr bool _Is_predicate_equal = _Is_any_of_v<_Pr,
+#if _HAS_CXX20
+        _RANGES equal_to,
+#endif // _HAS_CXX20
+        _STD equal_to<>>;
+
+    if constexpr (_Is_ranges_random_iter_v<decltype(_UFirst2)> && _Is_predicate_equal) {
+        const auto _Count2 = _ULast2 - _UFirst2;
+        if (_Count2 == 1) {
+            _UFirst1 = _STD _Find_unchecked(_STD move(_UFirst1), _STD move(_ULast1), *_UFirst2);
+            _STD _Seek_wrapped(_First1, _UFirst1);
+            return _First1;
+        }
+    }
+
 #if _USE_STD_VECTOR_ALGORITHMS
     if constexpr (_Vector_alg_in_find_first_of_is_safe<decltype(_UFirst1), decltype(_UFirst2), _Pr>) {
         if (!_STD _Is_constant_evaluated() && _ULast1 - _UFirst1 >= _Threshold_find_first_of) {
@@ -3531,14 +3547,23 @@ namespace ranges {
 
     private:
         template <class _It1, class _Se1, class _It2, class _Se2, class _Pr, class _Pj1, class _Pj2>
-        _NODISCARD static constexpr _It1 _Find_first_of_unchecked(_It1 _First1, const _Se1 _Last1, const _It2 _First2,
-            const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
+        _NODISCARD static constexpr _It1 _Find_first_of_unchecked(
+            _It1 _First1, _Se1 _Last1, const _It2 _First2, const _Se2 _Last2, _Pr _Pred, _Pj1 _Proj1, _Pj2 _Proj2) {
             _STL_INTERNAL_STATIC_ASSERT(input_iterator<_It1>);
             _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se1, _It1>);
             _STL_INTERNAL_STATIC_ASSERT(forward_iterator<_It2>);
             _STL_INTERNAL_STATIC_ASSERT(sentinel_for<_Se2, _It2>);
             _STL_INTERNAL_STATIC_ASSERT(indirectly_comparable<_It1, _It2, _Pr, _Pj1, _Pj2>);
 
+            if constexpr (_Is_ranges_random_iter_v<_It2> && sized_sentinel_for<_Se2, _It2>
+                          && _Is_any_of_v<_Pr, _STD equal_to<>, _RANGES equal_to>) {
+                const auto _Count2 = _Last2 - _First2;
+                if (_Count2 == 1) {
+                    return _RANGES _Find_unchecked(
+                        _STD move(_First1), _STD move(_Last1), _STD invoke(_Proj2, *_First2), _Proj1);
+                }
+            }
+
 #if _USE_STD_VECTOR_ALGORITHMS
             if constexpr (_Vector_alg_in_find_first_of_is_safe<_It1, _It2, _Pr> && sized_sentinel_for<_Se1, _It1>
                           && sized_sentinel_for<_Se2, _It2> && is_same_v<_Pj1, identity> && is_same_v<_Pj2, identity>) {

From c0fe1fae72bcd6bce1dd83d951a4b740c1d17efe Mon Sep 17 00:00:00 2001
From: "Stephan T. Lavavej" <stl@microsoft.com>
Date: Fri, 12 Apr 2024 11:09:33 -0700
Subject: [PATCH 39/45] Toolset update: VS 2022 17.10 Preview 3 (#4576)

---
 README.md                                     |   4 +-
 azure-devops/cmake-configure-build.yml        |   1 -
 azure-devops/config.yml                       |   2 +-
 azure-devops/create-1es-hosted-pool.ps1       |  37 +--
 azure-devops/provision-image.ps1              | 269 ++++--------------
 stl/inc/exception                             |   6 -
 stl/inc/new                                   |  10 -
 stl/inc/ranges                                |  14 -
 stl/inc/type_traits                           |  10 -
 stl/inc/typeinfo                              |  17 +-
 stl/modules/std.ixx                           |  78 -----
 .../test.compile.pass.cpp                     |   2 +-
 tests/std/tests/P0898R3_concepts/test.cpp     |   2 -
 13 files changed, 71 insertions(+), 381 deletions(-)

diff --git a/README.md b/README.md
index 351d7588a17..80682b0ba3d 100644
--- a/README.md
+++ b/README.md
@@ -141,7 +141,7 @@ Just try to follow these rules, so we can spend more time fixing bugs and implem
 
 # How To Build With The Visual Studio IDE
 
-1. Install Visual Studio 2022 17.10 Preview 2 or later.
+1. Install Visual Studio 2022 17.10 Preview 3 or later.
     * Select "Windows 11 SDK (10.0.22621.0)" in the VS Installer.
     * We recommend selecting "C++ CMake tools for Windows" in the VS Installer.
     This will ensure that you're using supported versions of CMake and Ninja.
@@ -156,7 +156,7 @@ Just try to follow these rules, so we can spend more time fixing bugs and implem
 
 # How To Build With A Native Tools Command Prompt
 
-1. Install Visual Studio 2022 17.10 Preview 2 or later.
+1. Install Visual Studio 2022 17.10 Preview 3 or later.
     * Select "Windows 11 SDK (10.0.22621.0)" in the VS Installer.
     * We recommend selecting "C++ CMake tools for Windows" in the VS Installer.
     This will ensure that you're using supported versions of CMake and Ninja.
diff --git a/azure-devops/cmake-configure-build.yml b/azure-devops/cmake-configure-build.yml
index 03605a85866..441be5792ab 100644
--- a/azure-devops/cmake-configure-build.yml
+++ b/azure-devops/cmake-configure-build.yml
@@ -19,7 +19,6 @@ parameters:
 - name: litFlags
   type: object
   default:
-    - '--timeout=240'
     - '-j$(testParallelism)'
     - '--xunit-xml-output=$(buildOutputLocation)/test-results.xml'
     - '--order=lexical'
diff --git a/azure-devops/config.yml b/azure-devops/config.yml
index 33caf0b137a..412ac16ed21 100644
--- a/azure-devops/config.yml
+++ b/azure-devops/config.yml
@@ -5,7 +5,7 @@
 
 variables:
 - name: poolName
-  value: 'StlBuild-2024-03-12T1202-Pool'
+  value: 'StlBuild-2024-04-10T1048-Pool'
   readonly: true
 - name: poolDemands
   value: 'EnableSpotVM -equals true'
diff --git a/azure-devops/create-1es-hosted-pool.ps1 b/azure-devops/create-1es-hosted-pool.ps1
index bba0c57a831..9aaf950bfd2 100644
--- a/azure-devops/create-1es-hosted-pool.ps1
+++ b/azure-devops/create-1es-hosted-pool.ps1
@@ -60,28 +60,11 @@ function New-Password {
   Param([int]$Length = 32)
 
   # This 64-character alphabet generates 6 bits of entropy per character.
-  # The power-of-2 alphabet size allows us to select a character by masking a random Byte with bitwise-AND.
-  $alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-'
-  $mask = 63
-  if ($alphabet.Length -ne 64) {
-    throw 'Bad alphabet length'
-  }
-
-  [Byte[]]$randomData = [Byte[]]::new($Length)
-  $rng = $null
-  try {
-    $rng = [System.Security.Cryptography.RandomNumberGenerator]::Create()
-    $rng.GetBytes($randomData)
-  }
-  finally {
-    if ($null -ne $rng) {
-      $rng.Dispose()
-    }
-  }
+  $alphabet = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789_-'.ToCharArray()
 
   [SecureString] $result = [SecureString]::new()
   for ($idx = 0; $idx -lt $Length; $idx++) {
-    $result.AppendChar($alphabet[$randomData[$idx] -band $mask])
+    $result.AppendChar((Get-SecureRandom -InputObject $alphabet))
   }
 
   return $result
@@ -121,6 +104,8 @@ function Wait-Shutdown {
 Display-ProgressBar -Status 'Silencing breaking change warnings'
 
 # https://aka.ms/azps-changewarnings
+$Env:SuppressAzurePowerShellBreakingChangeWarnings = 'true'
+
 Update-AzConfig `
   -DisplayBreakingChangeWarning $false `
   -Scope 'Process' | Out-Null
@@ -231,10 +216,9 @@ $ProvisionImageResult = Invoke-AzVMRunCommand `
   -ResourceGroupName $ResourceGroupName `
   -VMName $ProtoVMName `
   -CommandId 'RunPowerShellScript' `
-  -ScriptPath "$PSScriptRoot\provision-image.ps1" `
-  -Parameter @{ 'AdminUserPassword' = $AdminPW; }
+  -ScriptPath "$PSScriptRoot\provision-image.ps1"
 
-Write-Host "provision-image.ps1 output: $($ProvisionImageResult.value.Message)"
+Write-Host $ProvisionImageResult.value.Message
 
 ####################################################################################################
 Display-ProgressBar -Status 'Restarting VM'
@@ -330,7 +314,7 @@ $ImageVersion = New-AzGalleryImageVersion `
   -GalleryName $GalleryName `
   -GalleryImageDefinitionName $ImageDefinitionName `
   -Name $ImageVersionName `
-  -SourceImageId $VM.ID
+  -SourceImageVMId $VM.ID
 
 ####################################################################################################
 Display-ProgressBar -Status 'Registering CloudTest resource provider'
@@ -415,4 +399,9 @@ Remove-AzNetworkSecurityGroup `
 Write-Progress -Activity $ProgressActivity -Completed
 
 Write-Host "Elapsed time: $(((Get-Date) - $CurrentDate).ToString('hh\:mm\:ss'))"
-Write-Host "Finished creating pool: $PoolName"
+
+if ((Get-AzResource -ResourceGroupName $ResourceGroupName -Name $PoolName) -ne $null) {
+  Write-Host "Created pool: $PoolName"
+} else {
+  Write-Error "Failed to create pool: $PoolName"
+}
diff --git a/azure-devops/provision-image.ps1 b/azure-devops/provision-image.ps1
index e68adf909cb..ee3f0ab1a6d 100644
--- a/azure-devops/provision-image.ps1
+++ b/azure-devops/provision-image.ps1
@@ -10,20 +10,10 @@ provision-image.ps1 runs on an existing, freshly provisioned virtual machine,
 and sets up that virtual machine as a build machine. After this is done,
 (outside of this script), we take that machine and make it an image to be copied
 for setting up new VMs in the scale set.
-
-This script must either be run as admin, or one must pass AdminUserPassword;
-if the script is run with AdminUserPassword, it runs itself again as an
-administrator.
-
-.PARAMETER AdminUserPassword
-The administrator user's password; if this is $null, or not passed, then the
-script assumes it's running on an administrator account.
 #>
-param(
-  [string]$AdminUserPassword = $null
-)
 
 $ErrorActionPreference = 'Stop'
+$ProgressPreference = 'SilentlyContinue'
 
 <#
 .SYNOPSIS
@@ -37,14 +27,11 @@ filename component in the temporary directory with that extension.
 The extension to use for the path.
 #>
 Function Get-TempFilePath {
+  [CmdletBinding(PositionalBinding=$false)]
   Param(
-    [String]$Extension
+    [Parameter(Mandatory)][String]$Extension
   )
 
-  if ([String]::IsNullOrWhiteSpace($Extension)) {
-    throw 'Missing Extension'
-  }
-
   $tempPath = [System.IO.Path]::GetTempPath()
   $tempName = [System.IO.Path]::GetRandomFileName() + '.' + $Extension
   return Join-Path $tempPath $tempName
@@ -61,34 +48,22 @@ DownloadAndExtractZip returns a path containing the extracted contents.
 The URL of the ZIP file to download.
 #>
 Function DownloadAndExtractZip {
+  [CmdletBinding(PositionalBinding=$false)]
   Param(
-    [String]$Url
+    [Parameter(Mandatory)][String]$Url
   )
 
-  if ([String]::IsNullOrWhiteSpace($Url)) {
-    throw 'Missing Url'
-  }
-
   $ZipPath = Get-TempFilePath -Extension 'zip'
-  & curl.exe -L -o $ZipPath -s -S $Url
+  curl.exe -L -o $ZipPath -s -S $Url
   $TempSubdirPath = Get-TempFilePath -Extension 'dir'
   Expand-Archive -Path $ZipPath -DestinationPath $TempSubdirPath -Force
+  Remove-Item -Path $ZipPath
 
   return $TempSubdirPath
 }
 
-$TranscriptPath = 'C:\provision-image-transcript.txt'
-
-if ([string]::IsNullOrEmpty($AdminUserPassword)) {
-  Start-Transcript -Path $TranscriptPath -UseMinimalHeader
-} else {
-  Write-Host 'AdminUser password supplied; switching to AdminUser.'
-
-  # https://learn.microsoft.com/en-us/sysinternals/downloads/psexec
-  $PsToolsZipUrl = 'https://download.sysinternals.com/files/PSTools.zip'
-  Write-Host "Downloading: $PsToolsZipUrl"
-  $ExtractedPsToolsPath = DownloadAndExtractZip -Url $PsToolsZipUrl
-  $PsExecPath = Join-Path $ExtractedPsToolsPath 'PsExec64.exe'
+if ($PSVersionTable.PSVersion -lt [Version]::new('7.4.1')) {
+  Write-Host "Old PowerShell version: $($PSVersionTable.PSVersion)"
 
   # https://github.com/PowerShell/PowerShell/releases/latest
   $PowerShellZipUrl = 'https://github.com/PowerShell/PowerShell/releases/download/v7.4.1/PowerShell-7.4.1-win-x64.zip'
@@ -96,33 +71,21 @@ if ([string]::IsNullOrEmpty($AdminUserPassword)) {
   $ExtractedPowerShellPath = DownloadAndExtractZip -Url $PowerShellZipUrl
   $PwshPath = Join-Path $ExtractedPowerShellPath 'pwsh.exe'
 
-  $PsExecArgs = @(
-    '-u',
-    'AdminUser',
-    '-p',
-    'AdminUserPassword_REDACTED',
-    '-accepteula',
-    '-i',
-    '-h',
-    $PwshPath,
+  $PwshArgs = @(
     '-ExecutionPolicy',
     'Unrestricted',
     '-File',
     $PSCommandPath
   )
-  Write-Host "Executing: $PsExecPath $PsExecArgs"
-  $PsExecArgs[3] = $AdminUserPassword
+  Write-Host "Executing: $PwshPath $PwshArgs"
+  & $PwshPath $PwshArgs
 
-  $proc = Start-Process -FilePath $PsExecPath -ArgumentList $PsExecArgs -Wait -PassThru
-  Write-Host 'Reading transcript...'
-  Get-Content -Path $TranscriptPath
   Write-Host 'Cleaning up...'
-  Remove-Item -Recurse -Path $ExtractedPsToolsPath
   Remove-Item -Recurse -Path $ExtractedPowerShellPath
-  exit $proc.ExitCode
+  exit
 }
 
-$Workloads = @(
+$VisualStudioWorkloads = @(
   'Microsoft.VisualStudio.Component.VC.ASAN',
   'Microsoft.VisualStudio.Component.VC.CLI.Support',
   'Microsoft.VisualStudio.Component.VC.CMake.Project',
@@ -135,204 +98,78 @@ $Workloads = @(
   'Microsoft.VisualStudio.Component.Windows11SDK.22621'
 )
 
-$VisualStudioBootstrapperUrl = 'https://aka.ms/vs/17/pre/vs_enterprise.exe'
-$PythonUrl = 'https://www.python.org/ftp/python/3.12.2/python-3.12.2-amd64.exe'
-
-$CudaUrl = 'https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_551.61_windows.exe'
-
-$ErrorActionPreference = 'Stop'
-$ProgressPreference = 'SilentlyContinue'
-
-<#
-.SYNOPSIS
-Writes a message to the screen depending on ExitCode.
-
-.DESCRIPTION
-Since msiexec can return either 0 or 3010 successfully, in both cases
-we write that installation succeeded, and which exit code it exited with.
-If msiexec returns anything else, we write an error.
-
-.PARAMETER ExitCode
-The exit code that msiexec returned.
-#>
-Function PrintMsiExitCodeMessage {
-  Param(
-    $ExitCode
-  )
-
-  # 3010 is probably ERROR_SUCCESS_REBOOT_REQUIRED
-  if ($ExitCode -eq 0 -or $ExitCode -eq 3010) {
-    Write-Host "Installation successful! Exited with $ExitCode."
-  }
-  else {
-    Write-Error "Installation failed! Exited with $ExitCode."
-  }
+$VisualStudioUrl = 'https://aka.ms/vs/17/pre/vs_enterprise.exe'
+$VisualStudioArgs = @('--quiet', '--norestart', '--wait', '--nocache')
+foreach ($workload in $VisualStudioWorkloads) {
+  $VisualStudioArgs += '--add'
+  $VisualStudioArgs += $workload
 }
 
-<#
-.SYNOPSIS
-Install Visual Studio.
-
-.DESCRIPTION
-InstallVisualStudio takes the $Workloads array, and installs it with the
-installer that's pointed at by $BootstrapperUrl.
+$PythonUrl = 'https://www.python.org/ftp/python/3.12.3/python-3.12.3-amd64.exe'
+$PythonArgs = @('/quiet', 'InstallAllUsers=1', 'PrependPath=1', 'CompileAll=1', 'Include_doc=0')
 
-.PARAMETER Workloads
-The set of VS workloads to install.
-
-.PARAMETER BootstrapperUrl
-The URL of the Visual Studio installer, i.e. one of vs_*.exe.
-#>
-Function InstallVisualStudio {
-  Param(
-    [String[]]$Workloads,
-    [String]$BootstrapperUrl
-  )
-
-  try {
-    Write-Host 'Downloading Visual Studio...'
-    [string]$bootstrapperExe = Get-TempFilePath -Extension 'exe'
-    curl.exe -L -o $bootstrapperExe -s -S $BootstrapperUrl
-    Write-Host 'Installing Visual Studio...'
-    $args = @('/c', $bootstrapperExe, '--quiet', '--norestart', '--wait', '--nocache')
-    foreach ($workload in $Workloads) {
-      $args += '--add'
-      $args += $workload
-    }
-
-    $proc = Start-Process -FilePath cmd.exe -ArgumentList $args -Wait -PassThru
-    PrintMsiExitCodeMessage $proc.ExitCode
-  }
-  catch {
-    Write-Error "Failed to install Visual Studio! $($_.Exception.Message)"
-  }
-}
+$CudaUrl = 'https://developer.download.nvidia.com/compute/cuda/12.4.0/local_installers/cuda_12.4.0_551.61_windows.exe'
+$CudaArgs = @('-s')
 
 <#
 .SYNOPSIS
-Installs Python.
+Download and install a component.
 
 .DESCRIPTION
-InstallPython installs Python from the supplied URL.
+DownloadAndInstall downloads an executable from the given URL, and runs it with the given command-line arguments.
 
-.PARAMETER Url
-The URL of the Python installer.
-#>
-Function InstallPython {
-  Param(
-    [String]$Url
-  )
-
-  Write-Host 'Downloading Python...'
-  [string]$installerPath = Get-TempFilePath -Extension 'exe'
-  curl.exe -L -o $installerPath -s -S $Url
-  Write-Host 'Installing Python...'
-  $proc = Start-Process -FilePath $installerPath -ArgumentList `
-  @('/passive', 'InstallAllUsers=1', 'PrependPath=1', 'CompileAll=1') -Wait -PassThru
-  $exitCode = $proc.ExitCode
-  if ($exitCode -eq 0) {
-    Write-Host 'Installation successful!'
-  }
-  else {
-    Write-Error "Installation failed! Exited with $exitCode."
-  }
-}
-
-<#
-.SYNOPSIS
-Installs NVIDIA's CUDA Toolkit.
-
-.DESCRIPTION
-InstallCuda installs the CUDA Toolkit.
+.PARAMETER Name
+The name of the component, to be displayed in logging messages.
 
 .PARAMETER Url
-The URL of the CUDA installer.
+The URL of the installer.
+
+.PARAMETER Args
+The command-line arguments to pass to the installer.
 #>
-Function InstallCuda {
+Function DownloadAndInstall {
+  [CmdletBinding(PositionalBinding=$false)]
   Param(
-    [String]$Url
+    [Parameter(Mandatory)][String]$Name,
+    [Parameter(Mandatory)][String]$Url,
+    [Parameter(Mandatory)][String[]]$Args
   )
 
   try {
-    Write-Host 'Downloading CUDA...'
+    Write-Host "Downloading $Name..."
     [string]$installerPath = Get-TempFilePath -Extension 'exe'
     curl.exe -L -o $installerPath -s -S $Url
-    Write-Host 'Installing CUDA...'
-    $proc = Start-Process -FilePath $installerPath -ArgumentList @('-s') -Wait -PassThru
+
+    Write-Host "Installing $Name..."
+    $proc = Start-Process -FilePath $installerPath -ArgumentList $Args -Wait -PassThru
     $exitCode = $proc.ExitCode
+
     if ($exitCode -eq 0) {
       Write-Host 'Installation successful!'
-    }
-    else {
+    } elseif ($exitCode -eq 3010) {
+      Write-Host 'Installation successful! Exited with 3010 (ERROR_SUCCESS_REBOOT_REQUIRED).'
+    } else {
       Write-Error "Installation failed! Exited with $exitCode."
     }
-  }
-  catch {
-    Write-Error "Failed to install CUDA! $($_.Exception.Message)"
-  }
-}
-
-<#
-.SYNOPSIS
-Install or upgrade a pip package.
-
-.DESCRIPTION
-Installs or upgrades a pip package specified in $Package.
 
-.PARAMETER Package
-The name of the package to be installed or upgraded.
-#>
-Function PipInstall {
-  Param(
-    [String]$Package
-  )
-
-  try {
-    Write-Host "Installing or upgrading $Package..."
-    python.exe -m pip install --progress-bar off --upgrade $Package
-    Write-Host "Done installing or upgrading $Package."
-  }
-  catch {
-    Write-Error "Failed to install or upgrade $Package."
+    Remove-Item -Path $installerPath
+  } catch {
+    Write-Error "Installation failed! Exception: $($_.Exception.Message)"
   }
 }
 
-Write-Host 'AdminUser password not supplied; assuming already running as AdminUser.'
-
 # Print the Windows version, so we can verify whether Patch Tuesday has been picked up.
 cmd /c ver
 
-InstallPython $PythonUrl
-InstallVisualStudio -Workloads $Workloads -BootstrapperUrl $VisualStudioBootstrapperUrl
-InstallCuda -Url $CudaUrl
+DownloadAndInstall -Name 'Python'        -Url $PythonUrl       -Args $PythonArgs
+DownloadAndInstall -Name 'Visual Studio' -Url $VisualStudioUrl -Args $VisualStudioArgs
+DownloadAndInstall -Name 'CUDA'          -Url $CudaUrl         -Args $CudaArgs
 
-Write-Host 'Updating PATH...'
-
-# Step 1: Read the system path, which was just updated by installing Python.
-$currentSystemPath = [Environment]::GetEnvironmentVariable('Path', 'Machine')
-
-# Step 2: Update the local path (for this running script), so PipInstall can run python.exe.
-# Additional directories can be added here (e.g. if we extracted a zip file
-# or installed something that didn't update the system path).
-$Env:PATH="$($currentSystemPath)"
-
-# Step 3: Update the system path, permanently recording any additional directories that were added in the previous step.
-[Environment]::SetEnvironmentVariable('Path', "$Env:PATH", 'Machine')
-
-Write-Host 'Finished updating PATH!'
-
-Write-Host 'Running PipInstall...'
-
-PipInstall pip
-PipInstall psutil
-
-Write-Host 'Finished running PipInstall!'
-
-Write-Host 'Setting other environment variables...'
+Write-Host 'Setting environment variables...'
 
 # The STL's PR/CI builds are totally unrepresentative of customer usage.
 [Environment]::SetEnvironmentVariable('VSCMD_SKIP_SENDTELEMETRY', '1', 'Machine')
 
-Write-Host 'Finished setting other environment variables!'
-
 Write-Host 'Done!'
+
+exit
diff --git a/stl/inc/exception b/stl/inc/exception
index 3dcd5383965..fa826df924d 100644
--- a/stl/inc/exception
+++ b/stl/inc/exception
@@ -35,12 +35,6 @@ _STD_END
 
 _STD_BEGIN
 
-#ifndef _VCRT_EXPORT_STD // TRANSITION, VCRuntime update expected in 17.10 Preview 3
-// Follow N4971 [module.interface]/6 by exporting aliases (a type alias is not an entity, N4971 [basic.pre]/3):
-_EXPORT_STD using exception     = exception;
-_EXPORT_STD using bad_exception = bad_exception;
-#endif // ^^^ workaround ^^^
-
 _EXPORT_STD using ::terminate;
 
 #ifndef _M_CEE_PURE
diff --git a/stl/inc/new b/stl/inc/new
index ce5517781f9..e8f28cb06e9 100644
--- a/stl/inc/new
+++ b/stl/inc/new
@@ -18,16 +18,6 @@ _STL_DISABLE_CLANG_WARNINGS
 #undef new
 
 _STD_BEGIN
-#ifndef _VCRT_EXPORT_STD // TRANSITION, VCRuntime update expected in 17.10 Preview 3
-#if _HAS_EXCEPTIONS
-// Follow N4971 [module.interface]/6 by exporting aliases (a type alias is not an entity, N4971 [basic.pre]/3):
-_EXPORT_STD using bad_alloc            = bad_alloc;
-_EXPORT_STD using bad_array_new_length = bad_array_new_length;
-#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
-// <exception> exports bad_alloc and bad_array_new_length.
-#endif // ^^^ !_HAS_EXCEPTIONS ^^^
-#endif // ^^^ workaround ^^^
-
 #if _HAS_CXX20
 _EXPORT_STD struct destroying_delete_t {
     explicit destroying_delete_t() = default;
diff --git a/stl/inc/ranges b/stl/inc/ranges
index 6ceaec735d5..1407c82e45a 100644
--- a/stl/inc/ranges
+++ b/stl/inc/ranges
@@ -8979,7 +8979,6 @@ namespace ranges {
     concept _Regular_invocable_with_repeated_type =
         _Regular_invocable_with_repeated_type_impl<_Fn, _Ty, make_index_sequence<_Nx>>;
 
-#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-1975579
     template <class _Fn, class _Ty, class _Indices>
     struct _Invoke_result_with_repeated_type_impl;
 
@@ -8991,19 +8990,6 @@ namespace ranges {
     template <class _Fn, class _Ty, size_t _Nx>
     using _Invoke_result_with_repeated_type =
         _Invoke_result_with_repeated_type_impl<_Fn, _Ty, make_index_sequence<_Nx>>::type;
-#else // ^^^ no workaround / workaround vvv
-    template <class _Fn, class _Ty, size_t _Nx, class... _Types>
-    struct _Invoke_result_with_repeated_type_impl
-        : _Invoke_result_with_repeated_type_impl<_Fn, _Ty, _Nx - 1, _Ty, _Types...> {};
-
-    template <class _Fn, class _Ty, class... _Types>
-    struct _Invoke_result_with_repeated_type_impl<_Fn, _Ty, 0, _Types...> {
-        using type = invoke_result_t<_Fn, _Types...>;
-    };
-
-    template <class _Fn, class _Ty, size_t _Nx>
-    using _Invoke_result_with_repeated_type = _Invoke_result_with_repeated_type_impl<_Fn, _Ty, _Nx>::type;
-#endif // ^^^ workaround ^^^
 
     template <class _Vw, class _Fn, size_t _Nx>
     concept _Adjacent_transform_constraints =
diff --git a/stl/inc/type_traits b/stl/inc/type_traits
index 4a93f007b28..43e2ca6a37f 100644
--- a/stl/inc/type_traits
+++ b/stl/inc/type_traits
@@ -686,21 +686,11 @@ _EXPORT_STD template <class _Ty>
 _CXX17_DEPRECATE_IS_LITERAL_TYPE constexpr bool is_literal_type_v = __is_literal_type(_Ty);
 #endif // _HAS_DEPRECATED_IS_LITERAL_TYPE
 
-#if 1 // TRANSITION, VSO-119526 and LLVM-41915
-_EXPORT_STD template <class _Ty>
-struct is_trivial : bool_constant<__is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty)> {
-    // determine whether _Ty is a trivial type
-};
-
-_EXPORT_STD template <class _Ty>
-constexpr bool is_trivial_v = __is_trivially_constructible(_Ty) && __is_trivially_copyable(_Ty);
-#else // ^^^ workaround / no workaround vvv
 _EXPORT_STD template <class _Ty>
 struct is_trivial : bool_constant<__is_trivial(_Ty)> {}; // determine whether _Ty is a trivial type
 
 _EXPORT_STD template <class _Ty>
 constexpr bool is_trivial_v = __is_trivial(_Ty);
-#endif // ^^^ no workaround ^^^
 
 _EXPORT_STD template <class _Ty>
 struct is_trivially_copyable : bool_constant<__is_trivially_copyable(_Ty)> {
diff --git a/stl/inc/typeinfo b/stl/inc/typeinfo
index 1f9628652e0..e7df437d17a 100644
--- a/stl/inc/typeinfo
+++ b/stl/inc/typeinfo
@@ -23,27 +23,12 @@ _STL_DISABLE_CLANG_WARNINGS
 #include <vcruntime_typeinfo.h>
 #pragma pop_macro("raw_name")
 
-#ifndef _VCRT_EXPORT_STD // TRANSITION, VCRuntime update expected in 17.10 Preview 3
-// Follow N4971 [module.interface]/6 by exporting aliases (a type alias is not an entity, N4971 [basic.pre]/3):
-_EXPORT_STD using type_info = type_info; // for typeid, MSVC looks for type_info in the global namespace
-#endif // ^^^ workaround ^^^
-
 _STD_BEGIN
 
 // size in pointers of std::function and std::any (roughly 3 pointers larger than std::string when building debug)
 _INLINE_VAR constexpr int _Small_object_num_ptrs = 6 + 16 / sizeof(void*);
 
-#ifndef _VCRT_EXPORT_STD // TRANSITION, VCRuntime update expected in 17.10 Preview 3
-_EXPORT_STD using ::type_info;
-#endif // ^^^ workaround ^^^
-
-#if _HAS_EXCEPTIONS
-#ifndef _VCRT_EXPORT_STD // TRANSITION, VCRuntime update expected in 17.10 Preview 3
-// Follow N4971 [module.interface]/6 by exporting aliases (a type alias is not an entity, N4971 [basic.pre]/3):
-_EXPORT_STD using bad_cast   = bad_cast;
-_EXPORT_STD using bad_typeid = bad_typeid;
-#endif // ^^^ workaround ^^^
-#else // ^^^ _HAS_EXCEPTIONS / !_HAS_EXCEPTIONS vvv
+#if !_HAS_EXCEPTIONS
 _EXPORT_STD class bad_cast : public exception { // base of all bad cast exceptions
 public:
     bad_cast(const char* _Message = "bad cast") noexcept : exception(_Message) {}
diff --git a/stl/modules/std.ixx b/stl/modules/std.ixx
index 0aa355d9e8b..7a5fdbf7cef 100644
--- a/stl/modules/std.ixx
+++ b/stl/modules/std.ixx
@@ -36,84 +36,6 @@ export module std;
 #pragma warning(push)
 #pragma warning(disable : 5244) // '#include <meow>' in the purview of module 'std' appears erroneous.
 
-#include <yvals_core.h>
-#ifndef _VCRT_EXPORT_STD // TRANSITION, VCRuntime update expected in 17.10 Preview 3
-
-// N4971 [module.interface]/6: "A redeclaration of an entity X is implicitly exported
-// if X was introduced by an exported declaration; otherwise it shall not be exported."
-
-// Therefore, we need to introduce exported declarations of <vcruntime_new.h> machinery before including it.
-
-#pragma pack(push, _CRT_PACKING)
-#pragma warning(push, _STL_WARNING_LEVEL)
-#pragma warning(disable : _STL_DISABLED_WARNINGS)
-_STL_DISABLE_CLANG_WARNINGS
-#pragma push_macro("new")
-#undef new
-
-_STD_BEGIN
-export extern "C++" struct nothrow_t;
-
-export extern "C++" const nothrow_t nothrow;
-
-#ifdef __cpp_aligned_new
-export extern "C++" enum class align_val_t : size_t;
-#endif // ^^^ defined(__cpp_aligned_new) ^^^
-_STD_END
-
-export extern "C++" _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size)
-_VCRT_ALLOCATOR void* __CRTDECL operator new(size_t _Size);
-export extern "C++" _NODISCARD _Ret_maybenull_ _Success_(return != NULL)
-    _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR void* __CRTDECL
-    operator new(size_t _Size, const _STD nothrow_t&) noexcept;
-export extern "C++" _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size)
-_VCRT_ALLOCATOR void* __CRTDECL operator new[](size_t _Size);
-export extern "C++" _NODISCARD _Ret_maybenull_ _Success_(return != NULL)
-    _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR void* __CRTDECL
-    operator new[](size_t _Size, const _STD nothrow_t&) noexcept;
-export extern "C++" void __CRTDECL operator delete(void* _Block) noexcept;
-export extern "C++" void __CRTDECL operator delete(void* _Block, size_t _Size) noexcept;
-export extern "C++" void __CRTDECL operator delete(void* _Block, const _STD nothrow_t&) noexcept;
-export extern "C++" void __CRTDECL operator delete[](void* _Block) noexcept;
-export extern "C++" void __CRTDECL operator delete[](void* _Block, size_t _Size) noexcept;
-export extern "C++" void __CRTDECL operator delete[](void* _Block, const _STD nothrow_t&) noexcept;
-
-#ifdef __cpp_aligned_new
-export extern "C++" _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size)
-_VCRT_ALLOCATOR void* __CRTDECL operator new(size_t _Size, _STD align_val_t _Al);
-export extern "C++" _NODISCARD _Ret_maybenull_ _Success_(return != NULL)
-    _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR void* __CRTDECL
-    operator new(size_t _Size, _STD align_val_t _Al, const _STD nothrow_t&) noexcept;
-export extern "C++" _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size)
-_VCRT_ALLOCATOR void* __CRTDECL operator new[](size_t _Size, _STD align_val_t _Al);
-export extern "C++" _NODISCARD _Ret_maybenull_ _Success_(return != NULL)
-    _Post_writable_byte_size_(_Size) _VCRT_ALLOCATOR void* __CRTDECL
-    operator new[](size_t _Size, _STD align_val_t _Al, const _STD nothrow_t&) noexcept;
-export extern "C++" void __CRTDECL operator delete(void* _Block, _STD align_val_t _Al) noexcept;
-export extern "C++" void __CRTDECL operator delete(void* _Block, size_t _Size, _STD align_val_t _Al) noexcept;
-export extern "C++" void __CRTDECL operator delete(void* _Block, _STD align_val_t _Al, const _STD nothrow_t&) noexcept;
-export extern "C++" void __CRTDECL operator delete[](void* _Block, _STD align_val_t _Al) noexcept;
-export extern "C++" void __CRTDECL operator delete[](void* _Block, size_t _Size, _STD align_val_t _Al) noexcept;
-export extern "C++" void __CRTDECL operator delete[](
-    void* _Block, _STD align_val_t _Al, const _STD nothrow_t&) noexcept;
-#endif // ^^^ defined(__cpp_aligned_new) ^^^
-
-export extern "C++" _NODISCARD _MSVC_CONSTEXPR _Ret_notnull_ _Post_writable_byte_size_(_Size)
-    _Post_satisfies_(return == _Where) void* __CRTDECL
-    operator new(size_t _Size, _Writable_bytes_(_Size) void* _Where) noexcept;
-export extern "C++" _NODISCARD _Ret_notnull_ _Post_writable_byte_size_(_Size)
-    _Post_satisfies_(return == _Where) void* __CRTDECL
-    operator new[](size_t _Size, _Writable_bytes_(_Size) void* _Where) noexcept;
-export extern "C++" void __CRTDECL operator delete(void*, void*) noexcept;
-export extern "C++" void __CRTDECL operator delete[](void*, void*) noexcept;
-
-#pragma pop_macro("new")
-_STL_RESTORE_CLANG_WARNINGS
-#pragma warning(pop)
-#pragma pack(pop)
-
-#endif // ^^^ workaround ^^^
-
 // "C++ library headers" [tab:headers.cpp]
 #include <algorithm>
 #if _HAS_STATIC_RTTI
diff --git a/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp b/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
index 42755c4908d..e91f8837942 100644
--- a/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
+++ b/tests/std/tests/P0896R4_ranges_algorithm_machinery/test.compile.pass.cpp
@@ -522,7 +522,7 @@ namespace dangling_test {
 
     STATIC_ASSERT(std::is_class_v<dangling>);
     STATIC_ASSERT(std::semiregular<dangling>);
-    STATIC_ASSERT(std::is_trivial_v<dangling>); // not guaranteed, but likely portable nonetheless
+    STATIC_ASSERT(std::is_trivially_default_constructible_v<dangling>);
 
     // dangling is constructible from any sequence of arguments without throwing
     STATIC_ASSERT(is_nothrow_constructible_v<dangling>);
diff --git a/tests/std/tests/P0898R3_concepts/test.cpp b/tests/std/tests/P0898R3_concepts/test.cpp
index 7a1f6a4ab60..25d325f814c 100644
--- a/tests/std/tests/P0898R3_concepts/test.cpp
+++ b/tests/std/tests/P0898R3_concepts/test.cpp
@@ -2223,7 +2223,6 @@ namespace test_copy_constructible {
     STATIC_ASSERT(test<Immobile const&>());
     STATIC_ASSERT(!test<Immobile const&&>());
 
-#if defined(__clang__) || defined(__EDG__) // TRANSITION, VSO-119526
     // https://github.com/ericniebler/stl2/issues/301
     struct NotMutableRef {
         NotMutableRef()                     = default;
@@ -2240,7 +2239,6 @@ namespace test_copy_constructible {
 
     STATIC_ASSERT(!copy_constructible<NotMutableRef>);
     STATIC_ASSERT(!copy_constructible<NotConstRefRef>);
-#endif // ^^^ no workaround ^^^
 
     struct UserProvidedCopy {
         UserProvidedCopy(UserProvidedCopy const&);

From c86e1e575a3035b37427c917e998b0056748b742 Mon Sep 17 00:00:00 2001
From: Casey Carter <cacarter@microsoft.com>
Date: Fri, 12 Apr 2024 11:18:47 -0700
Subject: [PATCH 40/45] Skip Component Governance autodetection (#4568)

---
 azure-devops/config.yml | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/azure-devops/config.yml b/azure-devops/config.yml
index 412ac16ed21..63c3d01266c 100644
--- a/azure-devops/config.yml
+++ b/azure-devops/config.yml
@@ -22,3 +22,6 @@ variables:
 - name: Codeql.SkipTaskAutoInjection
   value: true
   readonly: true
+- name: skipComponentGovernanceDetection
+  value: true
+  readonly: true

From 98391873455389262c61c3b68bc44cdeab40f712 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Fri, 12 Apr 2024 21:20:40 +0300
Subject: [PATCH 41/45] Vectorize `lexicographical_compare`! (#4552)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/src/mismatch.cpp                   |  31 +++-
 stl/inc/algorithm                             |  16 +-
 stl/inc/xutility                              |  53 ++++++-
 .../env.lst                                   |   3 +
 .../test.compile.pass.cpp                     |  44 +++---
 .../VSO_0000000_vector_algorithms/test.cpp    | 143 +++++++++++++-----
 6 files changed, 214 insertions(+), 76 deletions(-)

diff --git a/benchmarks/src/mismatch.cpp b/benchmarks/src/mismatch.cpp
index f6a3069ac22..2efe44a0a21 100644
--- a/benchmarks/src/mismatch.cpp
+++ b/benchmarks/src/mismatch.cpp
@@ -12,7 +12,12 @@ using namespace std;
 
 constexpr int64_t no_pos = -1;
 
-template <class T>
+enum class op {
+    mismatch,
+    lexi,
+};
+
+template <class T, op Op>
 void bm(benchmark::State& state) {
     vector<T> a(static_cast<size_t>(state.range(0)), T{'.'});
     vector<T> b(static_cast<size_t>(state.range(0)), T{'.'});
@@ -22,15 +27,27 @@ void bm(benchmark::State& state) {
     }
 
     for (auto _ : state) {
-        benchmark::DoNotOptimize(ranges::mismatch(a, b));
+        if constexpr (Op == op::mismatch) {
+            benchmark::DoNotOptimize(ranges::mismatch(a, b));
+        } else if constexpr (Op == op::lexi) {
+            benchmark::DoNotOptimize(ranges::lexicographical_compare(a, b));
+        }
     }
 }
 
-#define COMMON_ARGS Args({8, 3})->Args({24, 22})->Args({105, -1})->Args({4021, 3056})
+void common_args(auto bm) {
+    bm->Args({8, 3})->Args({24, 22})->Args({105, -1})->Args({4021, 3056});
+}
+
+BENCHMARK(bm<uint8_t, op::mismatch>)->Apply(common_args);
+BENCHMARK(bm<uint16_t, op::mismatch>)->Apply(common_args);
+BENCHMARK(bm<uint32_t, op::mismatch>)->Apply(common_args);
+BENCHMARK(bm<uint64_t, op::mismatch>)->Apply(common_args);
 
-BENCHMARK(bm<uint8_t>)->COMMON_ARGS;
-BENCHMARK(bm<uint16_t>)->COMMON_ARGS;
-BENCHMARK(bm<uint32_t>)->COMMON_ARGS;
-BENCHMARK(bm<uint64_t>)->COMMON_ARGS;
+BENCHMARK(bm<uint8_t, op::lexi>)->Apply(common_args); // still optimized without vector algorithms using memcmp
+BENCHMARK(bm<int8_t, op::lexi>)->Apply(common_args); // optimized with vector algorithms only
+BENCHMARK(bm<uint16_t, op::lexi>)->Apply(common_args);
+BENCHMARK(bm<uint32_t, op::lexi>)->Apply(common_args);
+BENCHMARK(bm<uint64_t, op::lexi>)->Apply(common_args);
 
 BENCHMARK_MAIN();
diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index f4bfbd75a14..df17fea0dba 100644
--- a/stl/inc/algorithm
+++ b/stl/inc/algorithm
@@ -10971,8 +10971,22 @@ namespace ranges {
                         _Num2 = SIZE_MAX;
                     }
 
-                    const int _Ans = _STD _Memcmp_count(_First1, _First2, (_STD min)(_Num1, _Num2));
+                    const size_t _Num = (_STD min)(_Num1, _Num2);
+#if _USE_STD_VECTOR_ALGORITHMS
+                    const auto _First1_ptr = _STD to_address(_First1);
+                    const auto _First2_ptr = _STD to_address(_First2);
+                    const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+                    if (_Pos == _Num2) {
+                        return false;
+                    } else if (_Pos == _Num1) {
+                        return true;
+                    } else {
+                        return _STD invoke(_Pred, _First1_ptr[_Pos], _First2_ptr[_Pos]);
+                    }
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+                    const int _Ans = _STD _Memcmp_count(_First1, _First2, _Num);
                     return _Memcmp_classification_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
                 }
             }
 
diff --git a/stl/inc/xutility b/stl/inc/xutility
index 7deba10afd4..a58ccea242c 100644
--- a/stl/inc/xutility
+++ b/stl/inc/xutility
@@ -5629,8 +5629,14 @@ namespace ranges {
 #endif // _HAS_CXX20
 
 template <class _Elem1, class _Elem2>
-constexpr bool _Lex_compare_memcmp_classify_elements = conjunction_v<_Is_character_or_bool<_Elem1>,
-    _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>, is_unsigned<_Elem2>>;
+constexpr bool _Lex_compare_memcmp_classify_elements =
+#if _USE_STD_VECTOR_ALGORITHMS
+    is_integral_v<_Elem1> && is_integral_v<_Elem2> && sizeof(_Elem1) == sizeof(_Elem2)
+    && is_unsigned_v<_Elem1> == is_unsigned_v<_Elem2>;
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+    conjunction_v<_Is_character_or_bool<_Elem1>, _Is_character_or_bool<_Elem2>, is_unsigned<_Elem1>,
+        is_unsigned<_Elem2>>;
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
 
 #ifdef __cpp_lib_byte
 template <>
@@ -5702,10 +5708,24 @@ _NODISCARD _CONSTEXPR20 bool lexicographical_compare(
         if (!_STD is_constant_evaluated())
 #endif // _HAS_CXX20
         {
-            const auto _Num1 = static_cast<size_t>(_ULast1 - _UFirst1);
-            const auto _Num2 = static_cast<size_t>(_ULast2 - _UFirst2);
-            const int _Ans   = _STD _Memcmp_count(_UFirst1, _UFirst2, (_STD min)(_Num1, _Num2));
+            const auto _Num1  = static_cast<size_t>(_ULast1 - _UFirst1);
+            const auto _Num2  = static_cast<size_t>(_ULast2 - _UFirst2);
+            const size_t _Num = (_STD min)(_Num1, _Num2);
+#if _USE_STD_VECTOR_ALGORITHMS
+            const auto _First1_ptr = _STD _To_address(_UFirst1);
+            const auto _First2_ptr = _STD _To_address(_UFirst2);
+            const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+            if (_Pos == _Num2) {
+                return false;
+            } else if (_Pos == _Num1) {
+                return true;
+            } else {
+                return _Pred(_First1_ptr[_Pos], _First2_ptr[_Pos]);
+            }
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+            const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num);
             return _Memcmp_pred{}(_Ans, 0) || (_Ans == 0 && _Num1 < _Num2);
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
         }
     }
 
@@ -5802,14 +5822,31 @@ _NODISCARD constexpr auto lexicographical_compare_three_way(const _InIt1 _First1
     using _Memcmp_pred = _Lex_compare_three_way_memcmp_classify<decltype(_UFirst1), decltype(_UFirst2), _Cmp>;
     if constexpr (!is_void_v<_Memcmp_pred>) {
         if (!_STD is_constant_evaluated()) {
-            const auto _Num1 = static_cast<size_t>(_ULast1 - _UFirst1);
-            const auto _Num2 = static_cast<size_t>(_ULast2 - _UFirst2);
-            const int _Ans   = _STD _Memcmp_count(_UFirst1, _UFirst2, (_STD min)(_Num1, _Num2));
+            const auto _Num1  = static_cast<size_t>(_ULast1 - _UFirst1);
+            const auto _Num2  = static_cast<size_t>(_ULast2 - _UFirst2);
+            const size_t _Num = (_STD min)(_Num1, _Num2);
+#if _USE_STD_VECTOR_ALGORITHMS
+            const auto _First1_ptr = _STD to_address(_UFirst1);
+            const auto _First2_ptr = _STD to_address(_UFirst2);
+            const size_t _Pos      = _Mismatch_vectorized<sizeof(*_First1_ptr)>(_First1_ptr, _First2_ptr, _Num);
+            if (_Pos == _Num1) {
+                return _Pos == _Num2 ? strong_ordering::equal : strong_ordering::less;
+            } else if (_Pos == _Num2) {
+                return strong_ordering::greater;
+            } else {
+                const auto _Val1 = _First1_ptr[_Pos];
+                const auto _Val2 = _First2_ptr[_Pos];
+                __assume(_Val1 != _Val2); // avoid one comparison
+                return _Comp(_Val1, _Val2);
+            }
+#else // ^^^ _USE_STD_VECTOR_ALGORITHMS / !_USE_STD_VECTOR_ALGORITHMS vvv
+            const int _Ans = _STD _Memcmp_count(_UFirst1, _UFirst2, _Num);
             if (_Ans == 0) {
                 return _Num1 <=> _Num2;
             } else {
                 return _Memcmp_pred{}(_Ans, 0);
             }
+#endif // ^^^ !_USE_STD_VECTOR_ALGORITHMS ^^^
         }
     }
 
diff --git a/tests/std/tests/GH_000431_lex_compare_memcmp_classify/env.lst b/tests/std/tests/GH_000431_lex_compare_memcmp_classify/env.lst
index 6ccc73d16ea..00256420b81 100644
--- a/tests/std/tests/GH_000431_lex_compare_memcmp_classify/env.lst
+++ b/tests/std/tests/GH_000431_lex_compare_memcmp_classify/env.lst
@@ -2,3 +2,6 @@
 # SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 
 RUNALL_INCLUDE ..\char8_t_matrix.lst
+RUNALL_CROSSLIST
+*	PM_CL="" # Test manual vectorization
+*	PM_CL="/D_USE_STD_VECTOR_ALGORITHMS=0" # Test memcmp optimization
diff --git a/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp b/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp
index 94d1542a686..8f6be97461a 100644
--- a/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp
+++ b/tests/std/tests/GH_000431_lex_compare_memcmp_classify/test.compile.pass.cpp
@@ -130,8 +130,10 @@ void test_lex_compare_memcmp_classify_for_types() {
     test_lex_compare_memcmp_classify_for_pred<expected_less, Type1, Type2, less<>>();
     test_lex_compare_memcmp_classify_for_pred<expected_greater, Type1, Type2, greater<>>();
 
-    test_lex_compare_memcmp_classify_for_pred<void, Type1, Type2, less<int>>();
-    test_lex_compare_memcmp_classify_for_pred<void, Type1, Type2, greater<int>>();
+    using bigger_type = conditional_t<sizeof(Type1) == sizeof(int), long long, int>;
+
+    test_lex_compare_memcmp_classify_for_pred<void, Type1, Type2, less<bigger_type>>();
+    test_lex_compare_memcmp_classify_for_pred<void, Type1, Type2, greater<bigger_type>>();
 
     test_lex_compare_memcmp_classify_for_pred<void, Type1, Type2, less<volatile Type1>>();
     test_lex_compare_memcmp_classify_for_pred<void, Type1, Type2, greater<volatile Type1>>();
@@ -176,13 +178,15 @@ void test_lex_compare_memcmp_classify_for_types() {
 #endif // _HAS_CXX20
 }
 
+constexpr bool vec_alg = _USE_STD_VECTOR_ALGORITHMS;
+
 template <bool Expected, class Type1, class Type2>
 void test_lex_compare_memcmp_classify_for_1byte_integrals() {
     test_lex_compare_memcmp_classify_for_types<Expected, Type1, Type2>();
 
-    test_lex_compare_memcmp_classify_for_opaque_preds<is_unsigned_v<char>, Type1, Type2, char>();
+    test_lex_compare_memcmp_classify_for_opaque_preds<is_unsigned_v<char> || vec_alg, Type1, Type2, char>();
     test_lex_compare_memcmp_classify_for_opaque_preds<true, Type1, Type2, unsigned char>();
-    test_lex_compare_memcmp_classify_for_opaque_preds<false, Type1, Type2, signed char>();
+    test_lex_compare_memcmp_classify_for_opaque_preds<vec_alg, Type1, Type2, signed char>();
 #ifdef __cpp_lib_char8_t
     test_lex_compare_memcmp_classify_for_opaque_preds<true, Type1, Type2, char8_t>();
 #endif // __cpp_lib_char8_t
@@ -224,14 +228,14 @@ bool operator<(const user_struct&, const user_struct&) {
 }
 
 void lex_compare_memcmp_classify_test_cases() {
-    // Allow unsigned 1 byte integrals
-    test_lex_compare_memcmp_classify_for_1byte_integrals<is_unsigned_v<char>, char, char>();
+    // Test 1 byte integrals
+    test_lex_compare_memcmp_classify_for_1byte_integrals<is_unsigned_v<char> || vec_alg, char, char>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<is_unsigned_v<char>, unsigned char, char>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<is_unsigned_v<char>, char, unsigned char>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<true, unsigned char, unsigned char>();
-    test_lex_compare_memcmp_classify_for_1byte_integrals<false, signed char, signed char>();
-    test_lex_compare_memcmp_classify_for_1byte_integrals<false, char, signed char>();
-    test_lex_compare_memcmp_classify_for_1byte_integrals<false, signed char, char>();
+    test_lex_compare_memcmp_classify_for_1byte_integrals<vec_alg, signed char, signed char>();
+    test_lex_compare_memcmp_classify_for_1byte_integrals<vec_alg && is_signed_v<char>, char, signed char>();
+    test_lex_compare_memcmp_classify_for_1byte_integrals<vec_alg && is_signed_v<char>, signed char, char>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<false, unsigned char, signed char>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<false, signed char, unsigned char>();
 #ifdef __cpp_lib_char8_t
@@ -252,8 +256,8 @@ void lex_compare_memcmp_classify_test_cases() {
     test_lex_compare_memcmp_classify_for_1byte_integrals<true, bool, char8_t>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<true, char8_t, bool>();
 #endif // __cpp_lib_char8_t
-    test_lex_compare_memcmp_classify_for_1byte_integrals<false, char, bool>();
-    test_lex_compare_memcmp_classify_for_1byte_integrals<false, bool, char>();
+    test_lex_compare_memcmp_classify_for_1byte_integrals<vec_alg && is_unsigned_v<char>, char, bool>();
+    test_lex_compare_memcmp_classify_for_1byte_integrals<vec_alg && is_unsigned_v<char>, bool, char>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<false, signed char, bool>();
     test_lex_compare_memcmp_classify_for_1byte_integrals<false, bool, signed char>();
 
@@ -278,13 +282,13 @@ void lex_compare_memcmp_classify_test_cases() {
     test_lex_compare_memcmp_classify_for_types<true, byte, byte>();
 #endif // __cpp_lib_byte
 
-    // Don't allow bigger integrals
+    // Test bigger integrals
     test_lex_compare_memcmp_classify_for_types<false, unsigned char, int>();
     test_lex_compare_memcmp_classify_for_types<false, int, unsigned char>();
-    test_lex_compare_memcmp_classify_for_types<false, int, int>();
-    test_lex_compare_memcmp_classify_for_types<false, unsigned int, unsigned int>();
-    test_lex_compare_memcmp_classify_for_types<false, short, short>();
-    test_lex_compare_memcmp_classify_for_types<false, unsigned short, unsigned short>();
+    test_lex_compare_memcmp_classify_for_types<vec_alg, int, int>();
+    test_lex_compare_memcmp_classify_for_types<vec_alg, unsigned int, unsigned int>();
+    test_lex_compare_memcmp_classify_for_types<vec_alg, short, short>();
+    test_lex_compare_memcmp_classify_for_types<vec_alg, unsigned short, unsigned short>();
 
     // Don't allow pointers
     test_lex_compare_memcmp_classify_for_types<false, int*, int*>();
@@ -298,9 +302,11 @@ void lex_compare_memcmp_classify_test_cases() {
     test_lex_compare_memcmp_classify_for_pred<less<int>, char8_t, char8_t, _Char_traits_lt<char_traits<char8_t>>>();
 #endif // __cpp_lib_char8_t
 
-    test_lex_compare_memcmp_classify_for_pred<void, wchar_t, wchar_t, _Char_traits_lt<char_traits<wchar_t>>>();
-    test_lex_compare_memcmp_classify_for_pred<void, char16_t, char16_t, _Char_traits_lt<char_traits<char16_t>>>();
-    test_lex_compare_memcmp_classify_for_pred<void, char32_t, char32_t, _Char_traits_lt<char_traits<char32_t>>>();
+    using vless = conditional_t<vec_alg, less<int>, void>;
+
+    test_lex_compare_memcmp_classify_for_pred<vless, wchar_t, wchar_t, _Char_traits_lt<char_traits<wchar_t>>>();
+    test_lex_compare_memcmp_classify_for_pred<vless, char16_t, char16_t, _Char_traits_lt<char_traits<char16_t>>>();
+    test_lex_compare_memcmp_classify_for_pred<vless, char32_t, char32_t, _Char_traits_lt<char_traits<char32_t>>>();
 
     // Test different containers
 #if _HAS_CXX20
diff --git a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
index 49fec16ea07..9d0dc896cfd 100644
--- a/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
+++ b/tests/std/tests/VSO_0000000_vector_algorithms/test.cpp
@@ -20,8 +20,9 @@
 #include <vector>
 
 #if _HAS_CXX20
+#include <compare>
 #include <ranges>
-#endif
+#endif // _HAS_CXX20
 
 #include "test_min_max_element_support.hpp"
 
@@ -388,20 +389,69 @@ auto last_known_good_mismatch(FwdIt first1, FwdIt last1, FwdIt first2, FwdIt las
     return make_pair(first1, first2);
 }
 
+template <class FwdIt>
+bool last_known_good_lex_compare(FwdIt first1, FwdIt last1, FwdIt first2, FwdIt last2) {
+    for (;; ++first1, ++first2) {
+        if (first2 == last2) {
+            return false;
+        } else if (first1 == last1) {
+            return true;
+        } else if (*first1 < *first2) {
+            return true;
+        } else if (*first2 < *first1) {
+            return false;
+        }
+    }
+}
+
+#if _HAS_CXX20
+template <class FwdIt>
+auto last_known_good_lex_compare_3way(FwdIt first1, FwdIt last1, FwdIt first2, FwdIt last2) {
+    for (;; ++first1, ++first2) {
+        if (first2 == last2) {
+            if (first1 == last1) {
+                return strong_ordering::equal;
+            } else {
+                return strong_ordering::greater;
+            }
+        } else if (first1 == last1) {
+            return strong_ordering::less;
+        } else {
+            auto order = *first1 <=> *first2;
+            if (order != 0) {
+                return order;
+            }
+        }
+    }
+}
+#endif // _HAS_CXX20
+
 template <class T>
-void test_case_mismatch(const vector<T>& a, const vector<T>& b) {
-    auto expected = last_known_good_mismatch(a.begin(), a.end(), b.begin(), b.end());
-    auto actual   = mismatch(a.begin(), a.end(), b.begin(), b.end());
-    assert(expected == actual);
+void test_case_mismatch_and_lex_compare_family(const vector<T>& a, const vector<T>& b) {
+    auto expected_mismatch = last_known_good_mismatch(a.begin(), a.end(), b.begin(), b.end());
+    auto actual_mismatch   = mismatch(a.begin(), a.end(), b.begin(), b.end());
+    assert(expected_mismatch == actual_mismatch);
+
+    auto expected_lex = last_known_good_lex_compare(a.begin(), a.end(), b.begin(), b.end());
+    auto actual_lex   = lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+    assert(expected_lex == actual_lex);
+
 #if _HAS_CXX20
-    auto ranges_actual = ranges::mismatch(a, b);
-    assert(get<0>(expected) == ranges_actual.in1);
-    assert(get<1>(expected) == ranges_actual.in2);
+    auto ranges_actual_mismatch = ranges::mismatch(a, b);
+    assert(get<0>(expected_mismatch) == ranges_actual_mismatch.in1);
+    assert(get<1>(expected_mismatch) == ranges_actual_mismatch.in2);
+
+    auto ranges_actual_lex = ranges::lexicographical_compare(a, b);
+    assert(expected_lex == ranges_actual_lex);
+
+    auto expected_lex_3way = last_known_good_lex_compare_3way(a.begin(), a.end(), b.begin(), b.end());
+    auto actual_lex_3way   = lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end());
+    assert(expected_lex_3way == actual_lex_3way);
 #endif // _HAS_CXX20
 }
 
 template <class T>
-void test_mismatch(mt19937_64& gen) {
+void test_mismatch_and_lex_compare_family(mt19937_64& gen) {
     constexpr size_t shrinkCount   = 4;
     constexpr size_t mismatchCount = 30;
     using TD                       = conditional_t<sizeof(T) == 1, int, T>;
@@ -413,13 +463,13 @@ void test_mismatch(mt19937_64& gen) {
 
     for (;;) {
         // equal
-        test_case_mismatch(input_a, input_b);
+        test_case_mismatch_and_lex_compare_family(input_a, input_b);
 
         // different sizes
         for (size_t i = 0; i != shrinkCount && !input_b.empty(); ++i) {
-            test_case_mismatch(input_a, input_b);
-            test_case_mismatch(input_b, input_a);
             input_b.pop_back();
+            test_case_mismatch_and_lex_compare_family(input_a, input_b);
+            test_case_mismatch_and_lex_compare_family(input_b, input_a);
         }
 
         // actual mismatch (or maybe not, depending on random)
@@ -429,8 +479,8 @@ void test_mismatch(mt19937_64& gen) {
             for (size_t attempts = 0; attempts < mismatchCount; ++attempts) {
                 const size_t possible_mismatch_pos = mismatch_dis(gen);
                 input_a[possible_mismatch_pos]     = static_cast<T>(dis(gen));
-                test_case_mismatch(input_a, input_b);
-                test_case_mismatch(input_b, input_a);
+                test_case_mismatch_and_lex_compare_family(input_a, input_b);
+                test_case_mismatch_and_lex_compare_family(input_b, input_a);
             }
         }
 
@@ -444,19 +494,30 @@ void test_mismatch(mt19937_64& gen) {
 }
 
 template <class C1, class C2>
-void test_mismatch_containers() {
+void test_mismatch_and_lex_compare_family_containers() {
     C1 a{'m', 'e', 'o', 'w', ' ', 'C', 'A', 'T', 'S'};
     C2 b{'m', 'e', 'o', 'w', ' ', 'K', 'I', 'T', 'T', 'E', 'N', 'S'};
-    const auto result_4 = mismatch(a.begin(), a.end(), b.begin(), b.end());
-    const auto result_3 = mismatch(a.begin(), a.end(), b.begin());
-    assert(get<0>(result_4) == a.begin() + 5);
-    assert(get<1>(result_4) == b.begin() + 5);
-    assert(get<0>(result_3) == a.begin() + 5);
-    assert(get<1>(result_3) == b.begin() + 5);
+
+    const auto result_mismatch_4 = mismatch(a.begin(), a.end(), b.begin(), b.end());
+    const auto result_mismatch_3 = mismatch(a.begin(), a.end(), b.begin());
+    assert(get<0>(result_mismatch_4) == a.begin() + 5);
+    assert(get<1>(result_mismatch_4) == b.begin() + 5);
+    assert(get<0>(result_mismatch_3) == a.begin() + 5);
+    assert(get<1>(result_mismatch_3) == b.begin() + 5);
+
+    const auto result_lex = lexicographical_compare(a.begin(), a.end(), b.begin(), b.end());
+    assert(result_lex == true);
+
 #if _HAS_CXX20
-    const auto result_r = ranges::mismatch(a, b);
-    assert(result_r.in1 == a.begin() + 5);
-    assert(result_r.in2 == b.begin() + 5);
+    const auto result_mismatch_r = ranges::mismatch(a, b);
+    assert(result_mismatch_r.in1 == a.begin() + 5);
+    assert(result_mismatch_r.in2 == b.begin() + 5);
+
+    const auto result_lex_r = ranges::lexicographical_compare(a, b);
+    assert(result_lex_r == true);
+
+    const auto result_lex_3way = lexicographical_compare_three_way(a.begin(), a.end(), b.begin(), b.end());
+    assert(result_lex_3way == strong_ordering::less);
 #endif // _HAS_CXX20
 }
 
@@ -751,23 +812,23 @@ void test_vector_algorithms(mt19937_64& gen) {
     test_case_min_max_element(
         vector<int64_t>{-6604286336755016904, -4365366089374418225, 6104371530830675888, -8582621853879131834});
 
-    test_mismatch<char>(gen);
-    test_mismatch<signed char>(gen);
-    test_mismatch<unsigned char>(gen);
-    test_mismatch<short>(gen);
-    test_mismatch<unsigned short>(gen);
-    test_mismatch<int>(gen);
-    test_mismatch<unsigned int>(gen);
-    test_mismatch<long long>(gen);
-    test_mismatch<unsigned long long>(gen);
-
-    test_mismatch_containers<vector<char>, vector<signed char>>();
-    test_mismatch_containers<vector<char>, vector<unsigned char>>();
-    test_mismatch_containers<vector<wchar_t>, vector<char>>();
-    test_mismatch_containers<const vector<char>, const vector<char>>();
-    test_mismatch_containers<vector<char>, const vector<char>>();
-    test_mismatch_containers<const vector<wchar_t>, vector<wchar_t>>();
-    test_mismatch_containers<vector<char>, vector<int>>();
+    test_mismatch_and_lex_compare_family<char>(gen);
+    test_mismatch_and_lex_compare_family<signed char>(gen);
+    test_mismatch_and_lex_compare_family<unsigned char>(gen);
+    test_mismatch_and_lex_compare_family<short>(gen);
+    test_mismatch_and_lex_compare_family<unsigned short>(gen);
+    test_mismatch_and_lex_compare_family<int>(gen);
+    test_mismatch_and_lex_compare_family<unsigned int>(gen);
+    test_mismatch_and_lex_compare_family<long long>(gen);
+    test_mismatch_and_lex_compare_family<unsigned long long>(gen);
+
+    test_mismatch_and_lex_compare_family_containers<vector<char>, vector<signed char>>();
+    test_mismatch_and_lex_compare_family_containers<vector<char>, vector<unsigned char>>();
+    test_mismatch_and_lex_compare_family_containers<vector<wchar_t>, vector<char>>();
+    test_mismatch_and_lex_compare_family_containers<const vector<char>, const vector<char>>();
+    test_mismatch_and_lex_compare_family_containers<vector<char>, const vector<char>>();
+    test_mismatch_and_lex_compare_family_containers<const vector<wchar_t>, vector<wchar_t>>();
+    test_mismatch_and_lex_compare_family_containers<vector<char>, vector<int>>();
 
     test_mismatch_sizes_and_alignments::test<char>();
     test_mismatch_sizes_and_alignments::test<short>();

From 886ef10aafc93fe40d6ee6442bb3aa79391a9545 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Fri, 12 Apr 2024 21:24:33 +0300
Subject: [PATCH 42/45] `vector_algorithms.cpp`: `find`, `find_last`, `count`:
 make AVX2 path avoid SSE path and (for some types) fallback (#4570)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 benchmarks/src/find_and_count.cpp | 49 ++++++++++------
 stl/src/vector_algorithms.cpp     | 92 +++++++++++++++++++++++--------
 2 files changed, 99 insertions(+), 42 deletions(-)

diff --git a/benchmarks/src/find_and_count.cpp b/benchmarks/src/find_and_count.cpp
index 7b205aee6a0..9c608bfe356 100644
--- a/benchmarks/src/find_and_count.cpp
+++ b/benchmarks/src/find_and_count.cpp
@@ -5,7 +5,9 @@
 #include <benchmark/benchmark.h>
 #include <cstddef>
 #include <cstdint>
+#include <cstdlib>
 #include <ranges>
+#include <vector>
 
 enum class Op {
     FindSized,
@@ -15,39 +17,50 @@ enum class Op {
 
 using namespace std;
 
-template <class T, size_t Size, size_t Pos, Op Operation>
+template <class T, Op Operation>
 void bm(benchmark::State& state) {
-    T a[Size];
+    const auto size = static_cast<size_t>(state.range(0));
+    const auto pos  = static_cast<size_t>(state.range(1));
 
-    fill_n(a, Size, T{'0'});
-    if constexpr (Pos < Size) {
-        a[Pos] = T{'1'};
+    vector<T> a(size, T{'0'});
+
+    if (pos < size) {
+        a[pos] = T{'1'};
     } else {
-        static_assert(Operation != Op::FindUnsized);
+        if constexpr (Operation == Op::FindUnsized) {
+            abort();
+        }
     }
 
     for (auto _ : state) {
         if constexpr (Operation == Op::FindSized) {
-            benchmark::DoNotOptimize(ranges::find(a, a + Size, T{'1'}));
+            benchmark::DoNotOptimize(ranges::find(a.begin(), a.end(), T{'1'}));
         } else if constexpr (Operation == Op::FindUnsized) {
-            benchmark::DoNotOptimize(ranges::find(a, unreachable_sentinel, T{'1'}));
+            benchmark::DoNotOptimize(ranges::find(a.begin(), unreachable_sentinel, T{'1'}));
         } else if constexpr (Operation == Op::Count) {
-            benchmark::DoNotOptimize(ranges::count(a, a + Size, T{'1'}));
+            benchmark::DoNotOptimize(ranges::count(a.begin(), a.end(), T{'1'}));
         }
     }
 }
 
-BENCHMARK(bm<uint8_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint8_t, 8021, 3056, Op::FindUnsized>);
-BENCHMARK(bm<uint8_t, 8021, 3056, Op::Count>);
+void common_args(auto bm) {
+    bm->Args({8021, 3056});
+    // AVX tail tests
+    bm->Args({63, 62})->Args({31, 30})->Args({15, 14})->Args({7, 6});
+}
+
+
+BENCHMARK(bm<uint8_t, Op::FindSized>)->Apply(common_args);
+BENCHMARK(bm<uint8_t, Op::FindUnsized>)->Apply(common_args);
+BENCHMARK(bm<uint8_t, Op::Count>)->Apply(common_args);
 
-BENCHMARK(bm<uint16_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint16_t, 8021, 3056, Op::Count>);
+BENCHMARK(bm<uint16_t, Op::FindSized>)->Apply(common_args);
+BENCHMARK(bm<uint16_t, Op::Count>)->Apply(common_args);
 
-BENCHMARK(bm<uint32_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint32_t, 8021, 3056, Op::Count>);
+BENCHMARK(bm<uint32_t, Op::FindSized>)->Apply(common_args);
+BENCHMARK(bm<uint32_t, Op::Count>)->Apply(common_args);
 
-BENCHMARK(bm<uint64_t, 8021, 3056, Op::FindSized>);
-BENCHMARK(bm<uint64_t, 8021, 3056, Op::Count>);
+BENCHMARK(bm<uint64_t, Op::FindSized>)->Apply(common_args);
+BENCHMARK(bm<uint64_t, Op::Count>)->Apply(common_args);
 
 BENCHMARK_MAIN();
diff --git a/stl/src/vector_algorithms.cpp b/stl/src/vector_algorithms.cpp
index 0eb3c4cf24d..2349d804e3f 100644
--- a/stl/src/vector_algorithms.cpp
+++ b/stl/src/vector_algorithms.cpp
@@ -1837,15 +1837,15 @@ namespace {
     template <class _Traits, class _Ty>
     const void* __stdcall __std_find_trivial_impl(const void* _First, const void* _Last, _Ty _Val) noexcept {
 #ifndef _M_ARM64EC
-        size_t _Size_bytes = _Byte_length(_First, _Last);
+        const size_t _Size_bytes = _Byte_length(_First, _Last);
 
-        const size_t _Avx_size = _Size_bytes & ~size_t{0x1F};
-        if (_Avx_size != 0 && _Use_avx2()) {
+        if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
             _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
 
             const __m256i _Comparand = _Traits::_Set_avx(_Val);
             const void* _Stop_at     = _First;
             _Advance_bytes(_Stop_at, _Avx_size);
+
             do {
                 const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_First));
                 const int _Bingo    = _mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand));
@@ -1858,14 +1858,30 @@ namespace {
 
                 _Advance_bytes(_First, 32);
             } while (_First != _Stop_at);
-            _Size_bytes &= 0x1F;
-        }
 
-        const size_t _Sse_size = _Size_bytes & ~size_t{0xF};
-        if (_Sse_size != 0 && _Use_sse42()) {
+            if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                const __m256i _Tail_mask = _Avx2_tail_mask_32(_Avx_tail_size >> 2);
+                const __m256i _Data      = _mm256_maskload_epi32(static_cast<const int*>(_First), _Tail_mask);
+                const int _Bingo =
+                    _mm256_movemask_epi8(_mm256_and_si256(_Traits::_Cmp_avx(_Data, _Comparand), _Tail_mask));
+
+                if (_Bingo != 0) {
+                    const unsigned long _Offset = _tzcnt_u32(_Bingo);
+                    _Advance_bytes(_First, _Offset);
+                    return _First;
+                }
+
+                _Advance_bytes(_First, _Avx_tail_size);
+            }
+
+            if constexpr (sizeof(_Ty) >= 4) {
+                return _First;
+            }
+        } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
             const __m128i _Comparand = _Traits::_Set_sse(_Val);
             const void* _Stop_at     = _First;
             _Advance_bytes(_Stop_at, _Sse_size);
+
             do {
                 const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_First));
                 const int _Bingo    = _mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand));
@@ -1892,15 +1908,15 @@ namespace {
     const void* __stdcall __std_find_last_trivial_impl(const void* _First, const void* _Last, _Ty _Val) noexcept {
         const void* const _Real_last = _Last;
 #ifndef _M_ARM64EC
-        size_t _Size_bytes = _Byte_length(_First, _Last);
+        const size_t _Size_bytes = _Byte_length(_First, _Last);
 
-        const size_t _Avx_size = _Size_bytes & ~size_t{0x1F};
-        if (_Avx_size != 0 && _Use_avx2()) {
+        if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
             _Zeroupper_on_exit _Guard; // TRANSITION, DevCom-10331414
 
             const __m256i _Comparand = _Traits::_Set_avx(_Val);
             const void* _Stop_at     = _Last;
             _Rewind_bytes(_Stop_at, _Avx_size);
+
             do {
                 _Rewind_bytes(_Last, 32);
                 const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_Last));
@@ -1912,14 +1928,29 @@ namespace {
                     return _Last;
                 }
             } while (_Last != _Stop_at);
-            _Size_bytes &= 0x1F;
-        }
 
-        const size_t _Sse_size = _Size_bytes & ~size_t{0xF};
-        if (_Sse_size != 0 && _Use_sse42()) {
+            if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                _Rewind_bytes(_Last, _Avx_tail_size);
+                const __m256i _Tail_mask = _Avx2_tail_mask_32(_Avx_tail_size >> 2);
+                const __m256i _Data      = _mm256_maskload_epi32(static_cast<const int*>(_Last), _Tail_mask);
+                const int _Bingo =
+                    _mm256_movemask_epi8(_mm256_and_si256(_Traits::_Cmp_avx(_Data, _Comparand), _Tail_mask));
+
+                if (_Bingo != 0) {
+                    const unsigned long _Offset = _lzcnt_u32(_Bingo);
+                    _Advance_bytes(_Last, (31 - _Offset) - (sizeof(_Ty) - 1));
+                    return _Last;
+                }
+            }
+
+            if constexpr (sizeof(_Ty) >= 4) {
+                return _Real_last;
+            }
+        } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
             const __m128i _Comparand = _Traits::_Set_sse(_Val);
             const void* _Stop_at     = _Last;
             _Rewind_bytes(_Stop_at, _Sse_size);
+
             do {
                 _Rewind_bytes(_Last, 16);
                 const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_Last));
@@ -1952,40 +1983,53 @@ namespace {
         size_t _Result = 0;
 
 #ifndef _M_ARM64EC
-        size_t _Size_bytes = _Byte_length(_First, _Last);
+        const size_t _Size_bytes = _Byte_length(_First, _Last);
 
-        const size_t _Avx_size = _Size_bytes & ~size_t{0x1F};
-        if (_Avx_size != 0 && _Use_avx2()) {
+        if (const size_t _Avx_size = _Size_bytes & ~size_t{0x1F}; _Avx_size != 0 && _Use_avx2()) {
             const __m256i _Comparand = _Traits::_Set_avx(_Val);
             const void* _Stop_at     = _First;
             _Advance_bytes(_Stop_at, _Avx_size);
+
             do {
                 const __m256i _Data = _mm256_loadu_si256(static_cast<const __m256i*>(_First));
                 const int _Bingo    = _mm256_movemask_epi8(_Traits::_Cmp_avx(_Data, _Comparand));
                 _Result += __popcnt(_Bingo); // Assume available with SSE4.2
                 _Advance_bytes(_First, 32);
             } while (_First != _Stop_at);
-            _Size_bytes &= 0x1F;
+
+            if (const size_t _Avx_tail_size = _Size_bytes & 0x1C; _Avx_tail_size != 0) {
+                const __m256i _Tail_mask = _Avx2_tail_mask_32(_Avx_tail_size >> 2);
+                const __m256i _Data      = _mm256_maskload_epi32(static_cast<const int*>(_First), _Tail_mask);
+                const int _Bingo =
+                    _mm256_movemask_epi8(_mm256_and_si256(_Traits::_Cmp_avx(_Data, _Comparand), _Tail_mask));
+                _Result += __popcnt(_Bingo); // Assume available with SSE4.2
+                _Advance_bytes(_First, _Avx_tail_size);
+            }
 
             _mm256_zeroupper(); // TRANSITION, DevCom-10331414
-        }
 
-        const size_t _Sse_size = _Size_bytes & ~size_t{0xF};
-        if (_Sse_size != 0 && _Use_sse42()) {
+            _Result >>= _Traits::_Shift;
+
+            if constexpr (sizeof(_Ty) >= 4) {
+                return _Result;
+            }
+        } else if (const size_t _Sse_size = _Size_bytes & ~size_t{0xF}; _Sse_size != 0 && _Use_sse42()) {
             const __m128i _Comparand = _Traits::_Set_sse(_Val);
             const void* _Stop_at     = _First;
             _Advance_bytes(_Stop_at, _Sse_size);
+
             do {
                 const __m128i _Data = _mm_loadu_si128(static_cast<const __m128i*>(_First));
                 const int _Bingo    = _mm_movemask_epi8(_Traits::_Cmp_sse(_Data, _Comparand));
                 _Result += __popcnt(_Bingo); // Assume available with SSE4.2
                 _Advance_bytes(_First, 16);
             } while (_First != _Stop_at);
+
+            _Result >>= _Traits::_Shift;
         }
 #endif // !_M_ARM64EC
-        _Result >>= _Traits::_Shift;
-        auto _Ptr = static_cast<const _Ty*>(_First);
-        for (; _Ptr != _Last; ++_Ptr) {
+
+        for (auto _Ptr = static_cast<const _Ty*>(_First); _Ptr != _Last; ++_Ptr) {
             if (*_Ptr == _Val) {
                 ++_Result;
             }

From 3697ebb51904a499ba0f9f4692aa5cd438e20dd3 Mon Sep 17 00:00:00 2001
From: Alex Guteniev <gutenev@gmail.com>
Date: Fri, 12 Apr 2024 21:32:01 +0300
Subject: [PATCH 43/45] `<yvals_core.h>`: avoid using the 'container' word for
 something that has `empty()` member in `[[nodiscard]]` messages (#4572)

---
 stl/inc/queue        |  4 ++--
 stl/inc/stack        |  2 +-
 stl/inc/stacktrace   |  2 +-
 stl/inc/yvals_core.h | 39 ++++++++++++++++-----------------------
 4 files changed, 20 insertions(+), 27 deletions(-)

diff --git a/stl/inc/queue b/stl/inc/queue
index 461f7054332..847ddc5e2e5 100644
--- a/stl/inc/queue
+++ b/stl/inc/queue
@@ -84,7 +84,7 @@ public:
         : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)) {}
 #endif // _HAS_CXX23
 
-    _NODISCARD_EMPTY_ADAPTOR_MEMBER bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
         return c.empty();
     }
 
@@ -354,7 +354,7 @@ public:
     }
 #endif // _HAS_CXX23
 
-    _NODISCARD_EMPTY_ADAPTOR_MEMBER bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
         return c.empty();
     }
 
diff --git a/stl/inc/stack b/stl/inc/stack
index c1f012eec2a..582e2873fe1 100644
--- a/stl/inc/stack
+++ b/stl/inc/stack
@@ -82,7 +82,7 @@ public:
         : c(_RANGES to<_Container>(_STD forward<_Rng>(_Range), _Al)) {}
 #endif // _HAS_CXX23
 
-    _NODISCARD_EMPTY_ADAPTOR_MEMBER bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept(noexcept(c.empty())) /* strengthened */ {
         return c.empty();
     }
 
diff --git a/stl/inc/stacktrace b/stl/inc/stacktrace
index 9d84b337368..cc182e617d9 100644
--- a/stl/inc/stacktrace
+++ b/stl/inc/stacktrace
@@ -232,7 +232,7 @@ public:
         return _Frames.crend();
     }
 
-    _NODISCARD_EMPTY_STACKTRACE_MEMBER bool empty() const noexcept {
+    _NODISCARD_EMPTY_MEMBER_NO_CLEAR bool empty() const noexcept {
         return _Frames.empty();
     }
 
diff --git a/stl/inc/yvals_core.h b/stl/inc/yvals_core.h
index cc016cbe848..ab51dea02b0 100644
--- a/stl/inc/yvals_core.h
+++ b/stl/inc/yvals_core.h
@@ -597,34 +597,27 @@
     _NODISCARD_MSG("The 'unique' algorithm returns the iterator past the last element that should be kept. " \
                    "You need to call container.erase(result, container.end()) afterwards.")
 
-#define _NODISCARD_EMPTY_MEMBER                                                                                    \
-    _NODISCARD_MSG(                                                                                                \
-        "This member function returns a bool indicating whether the container is empty and has no other effects. " \
-        "It is not useful to call this member function and discard the return value. "                             \
+#define _NODISCARD_EMPTY_MEMBER                                                                                     \
+    _NODISCARD_MSG(                                                                                                 \
+        "This member function returns a bool indicating whether the collection is empty and has no other effects. " \
+        "It is not useful to call this member function and discard the return value. "                              \
         "Use the 'clear()' member function if you want to erase all elements.")
 
-#define _NODISCARD_EMPTY_ARRAY_MEMBER                                                                              \
-    _NODISCARD_MSG(                                                                                                \
-        "This member function returns a bool indicating whether the container is empty and has no other effects. " \
-        "It is not useful to call this member function and discard the return value. "                             \
+#define _NODISCARD_EMPTY_ARRAY_MEMBER                                                                          \
+    _NODISCARD_MSG(                                                                                            \
+        "This member function returns a bool indicating whether the array is empty and has no other effects. " \
+        "It is not useful to call this member function and discard the return value. "                         \
         "There's no way to clear an array as its size is fixed.")
 
-#define _NODISCARD_EMPTY_STACKTRACE_MEMBER                                                                         \
-    _NODISCARD_MSG(                                                                                                \
-        "This member function returns a bool indicating whether the container is empty and has no other effects. " \
-        "It is not useful to call this member function and discard the return value. "                             \
-        "'std::stacktrace' can be cleared by assigning an empty value to it.")
+#define _NODISCARD_EMPTY_MEMBER_NO_CLEAR                                                                            \
+    _NODISCARD_MSG(                                                                                                 \
+        "This member function returns a bool indicating whether the collection is empty and has no other effects. " \
+        "It is not useful to call this member function and discard the return value. "                              \
+        "This collection can be cleared by assigning an empty value to it.")
 
-#define _NODISCARD_EMPTY_NON_MEMBER                                                                            \
-    _NODISCARD_MSG(                                                                                            \
-        "This function returns a bool indicating whether the container or container-like object is empty and " \
-        "has no other effects. It is not useful to call this function and discard the return value.")
-
-#define _NODISCARD_EMPTY_ADAPTOR_MEMBER                                                                            \
-    _NODISCARD_MSG(                                                                                                \
-        "This member function returns a bool indicating whether the container is empty and has no other effects. " \
-        "It is not useful to call this member function and discard the return value. "                             \
-        "Container adaptors don't provide 'clear()' member functions, but you can assign an empty object to them.")
+#define _NODISCARD_EMPTY_NON_MEMBER                                                               \
+    _NODISCARD_MSG("This function returns a bool indicating whether the collection is empty and " \
+                   "has no other effects. It is not useful to call this function and discard the return value.")
 
 #define _NODISCARD_BARRIER_TOKEN \
     _NODISCARD_MSG("The token from 'arrive()' should not be discarded; it should be passed to 'wait()'.")

From 213df0c3901c1ada67e33fba1a8441bc99a79e81 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?mq=E7=99=BD?= <3326284481@qq.com>
Date: Sat, 13 Apr 2024 02:36:47 +0800
Subject: [PATCH 44/45] Optimized string concatenation in
 `_Tzdb_update_version()` (#4577)

Co-authored-by: Stephan T. Lavavej <stl@microsoft.com>
---
 stl/inc/chrono | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/stl/inc/chrono b/stl/inc/chrono
index 3a94bdeca66..58c711194a5 100644
--- a/stl/inc/chrono
+++ b/stl/inc/chrono
@@ -2176,7 +2176,9 @@ namespace chrono {
 
     _NODISCARD inline string _Tzdb_update_version(const string_view _Version, const size_t _Num_leap_seconds) {
         string _Icu_version{_Version.substr(0, _Version.find_last_of('.'))};
-        return _STD move(_Icu_version) + "." + _STD to_string(_Num_leap_seconds);
+        _Icu_version += '.';
+        _Icu_version += _STD to_string(_Num_leap_seconds);
+        return _Icu_version;
     }
 
     struct _Secret_tzdb_list_construct_tag {

From 9aca22477df4eed3222b4974746ee79129eb44e7 Mon Sep 17 00:00:00 2001
From: "A. Jiang" <de34@live.cn>
Date: Sat, 13 Apr 2024 02:42:49 +0800
Subject: [PATCH 45/45] `<tuple>`, `<variant>`: Make error messages from
 get-by-type functions clearer (#4578)

Co-authored-by: Stephan T. Lavavej <stl@nuwen.net>
---
 stl/inc/__msvc_iter_core.hpp |  39 ++++++++++++++
 stl/inc/tuple                |  54 +++++++++++--------
 stl/inc/variant              | 102 +++++++++++++++--------------------
 3 files changed, 113 insertions(+), 82 deletions(-)

diff --git a/stl/inc/__msvc_iter_core.hpp b/stl/inc/__msvc_iter_core.hpp
index 0595c87184f..6107a8700aa 100644
--- a/stl/inc/__msvc_iter_core.hpp
+++ b/stl/inc/__msvc_iter_core.hpp
@@ -512,6 +512,45 @@ struct iterator_traits : _Iterator_traits_base<_Iter> {}; // get traits from ite
 template <class _Ty>
 struct iterator_traits<_Ty*> : _Iterator_traits_pointer_base<_Ty> {}; // get traits from pointer, if possible
 #endif // ^^^ !_HAS_CXX20 ^^^
+
+_INLINE_VAR constexpr auto _Meta_npos = ~size_t{0};
+
+constexpr size_t _Meta_find_index_i_(const bool* const _Ptr, const size_t _Count, size_t _Idx = 0) {
+    // return the index of the first true in the _Count bools at _Ptr, or _Meta_npos if all are false
+    for (; _Idx < _Count; ++_Idx) {
+        if (_Ptr[_Idx]) {
+            return _Idx;
+        }
+    }
+
+    return _Meta_npos;
+}
+
+template <class _List, class _Ty>
+struct _Meta_find_unique_index_ {
+    using type = integral_constant<size_t, _Meta_npos>;
+};
+template <class _List, class _Ty>
+using _Meta_find_unique_index =
+    // The index of _Ty in _List if it occurs exactly once, otherwise _Meta_npos
+    typename _Meta_find_unique_index_<_List, _Ty>::type;
+
+constexpr size_t _Meta_find_unique_index_i_2(const bool* const _Ptr, const size_t _Count, const size_t _First) {
+    // return _First if there is no _First < j < _Count such that _Ptr[j] is true, otherwise _Meta_npos
+    return _First != _Meta_npos && _STD _Meta_find_index_i_(_Ptr, _Count, _First + 1) == _Meta_npos ? _First
+                                                                                                    : _Meta_npos;
+}
+
+constexpr size_t _Meta_find_unique_index_i_(const bool* const _Ptr, const size_t _Count) {
+    // Pass the smallest i such that _Ptr[i] is true to _Meta_find_unique_index_i_2
+    return _STD _Meta_find_unique_index_i_2(_Ptr, _Count, _STD _Meta_find_index_i_(_Ptr, _Count));
+}
+
+template <template <class...> class _List, class _First, class... _Rest, class _Ty>
+struct _Meta_find_unique_index_<_List<_First, _Rest...>, _Ty> {
+    static constexpr bool _Bools[] = {is_same_v<_First, _Ty>, is_same_v<_Rest, _Ty>...};
+    using type = integral_constant<size_t, _STD _Meta_find_unique_index_i_(_Bools, 1 + sizeof...(_Rest))>;
+};
 _STD_END
 
 #pragma pop_macro("new")
diff --git a/stl/inc/tuple b/stl/inc/tuple
index 0d0cdb8f704..5571a7e1623 100644
--- a/stl/inc/tuple
+++ b/stl/inc/tuple
@@ -913,20 +913,6 @@ constexpr void swap(const tuple<_Types...>& _Left, const tuple<_Types...>& _Righ
 }
 #endif // _HAS_CXX23
 
-template <class _Ty, class _Tuple>
-struct _Tuple_element {}; // backstop _Tuple_element definition
-
-template <class _This, class... _Rest>
-struct _Tuple_element<_This, tuple<_This, _Rest...>> { // select first element
-    static_assert(!_Is_any_of_v<_This, _Rest...>, "duplicate type T in get<T>(tuple)");
-    using _Ttype = tuple<_This, _Rest...>;
-};
-
-template <class _Ty, class _This, class... _Rest>
-struct _Tuple_element<_Ty, tuple<_This, _Rest...>> { // recursive _Tuple_element definition
-    using _Ttype = typename _Tuple_element<_Ty, tuple<_Rest...>>::_Ttype;
-};
-
 _EXPORT_STD template <size_t _Index, class... _Types>
 _NODISCARD constexpr tuple_element_t<_Index, tuple<_Types...>>& get(tuple<_Types...>& _Tuple) noexcept {
     using _Ttype = typename tuple_element<_Index, tuple<_Types...>>::_Ttype;
@@ -963,26 +949,50 @@ _NODISCARD constexpr auto&& _Tuple_get(tuple<_Types...>&& _Tuple) noexcept {
 
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr _Ty& get(tuple<_Types...>& _Tuple) noexcept {
-    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
-    return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<_Ttype&>(_Tuple)._Myfirst._Val;
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(tuple<Types...>&) requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
 }
 
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr const _Ty& get(const tuple<_Types...>& _Tuple) noexcept {
-    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
-    return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<const _Ttype&>(_Tuple)._Myfirst._Val;
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(const tuple<Types...>&) requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
 }
 
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr _Ty&& get(tuple<_Types...>&& _Tuple) noexcept {
-    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
-    return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<_Ty&&>(static_cast<_Ttype&>(_Tuple)._Myfirst._Val);
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(tuple<Types...>&&) requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
 }
 
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr const _Ty&& get(const tuple<_Types...>&& _Tuple) noexcept {
-    using _Ttype = typename _Tuple_element<_Ty, tuple<_Types...>>::_Ttype;
-    return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
+    constexpr size_t _Idx = _Meta_find_unique_index<tuple<_Types...>, _Ty>::value;
+    if constexpr (_Idx < sizeof...(_Types)) {
+        using _Ttype = typename tuple_element<_Idx, tuple<_Types...>>::_Ttype;
+        return static_cast<const _Ty&&>(static_cast<const _Ttype&>(_Tuple)._Myfirst._Val);
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(const tuple<Types...>&&) requires T to occur exactly once in Types. (N4971 [tuple.elem]/5)");
+    }
 }
 
 template <class _This, class... _Rest>
diff --git a/stl/inc/variant b/stl/inc/variant
index 2690217f61b..4b8060c76ca 100644
--- a/stl/inc/variant
+++ b/stl/inc/variant
@@ -168,45 +168,6 @@ struct _Meta_at_<_List<_Types...>, _Idx, enable_if_t<(_Idx < sizeof...(_Types))>
 };
 #endif // ^^^ !defined(__clang__) ^^^
 
-inline constexpr auto _Meta_npos = ~size_t{0};
-
-constexpr size_t _Meta_find_index_i_(const bool* const _Ptr, const size_t _Count, size_t _Idx = 0) {
-    // return the index of the first true in the _Count bools at _Ptr, or _Meta_npos if all are false
-    for (; _Idx < _Count; ++_Idx) {
-        if (_Ptr[_Idx]) {
-            return _Idx;
-        }
-    }
-
-    return _Meta_npos;
-}
-
-template <class _List, class _Ty>
-struct _Meta_find_unique_index_ {
-    using type = integral_constant<size_t, _Meta_npos>;
-};
-template <class _List, class _Ty>
-using _Meta_find_unique_index =
-    // The index of _Ty in _List if it occurs exactly once, otherwise _Meta_npos
-    typename _Meta_find_unique_index_<_List, _Ty>::type;
-
-constexpr size_t _Meta_find_unique_index_i_2(const bool* const _Ptr, const size_t _Count, const size_t _First) {
-    // return _First if there is no _First < j < _Count such that _Ptr[j] is true, otherwise _Meta_npos
-    return _First != _Meta_npos && _STD _Meta_find_index_i_(_Ptr, _Count, _First + 1) == _Meta_npos ? _First
-                                                                                                    : _Meta_npos;
-}
-
-constexpr size_t _Meta_find_unique_index_i_(const bool* const _Ptr, const size_t _Count) {
-    // Pass the smallest i such that _Ptr[i] is true to _Meta_find_unique_index_i_2
-    return _STD _Meta_find_unique_index_i_2(_Ptr, _Count, _STD _Meta_find_index_i_(_Ptr, _Count));
-}
-
-template <template <class...> class _List, class _First, class... _Rest, class _Ty>
-struct _Meta_find_unique_index_<_List<_First, _Rest...>, _Ty> {
-    static constexpr bool _Bools[] = {is_same_v<_First, _Ty>, is_same_v<_Rest, _Ty>...};
-    using type = integral_constant<size_t, _STD _Meta_find_unique_index_i_(_Bools, 1 + sizeof...(_Rest))>;
-};
-
 template <class>
 struct _Meta_as_list_;
 template <class _Ty>
@@ -1179,9 +1140,12 @@ _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr bool holds_alternative(const variant<_Types...>& _Var) noexcept {
     // true iff _Var holds alternative _Ty
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx != _Meta_npos, "holds_alternative<T>(const variant<Types...>&) requires T to occur exactly "
-                                      "once in Types. (N4950 [variant.get]/1)");
-    return _Var.index() == _Idx;
+    if constexpr (_Idx != _Meta_npos) {
+        return _Var.index() == _Idx;
+    } else {
+        static_assert(_Always_false<_Ty>, "holds_alternative<T>(const variant<Types...>&) requires T to occur exactly "
+                                          "once in Types. (N4971 [variant.get]/1)");
+    }
 }
 
 _EXPORT_STD template <size_t _Idx, class... _Types>
@@ -1229,33 +1193,45 @@ _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(variant<_Types...>& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx < sizeof...(_Types),
-        "get<T>(variant<Types...>&) requires T to occur exactly once in Types. (N4950 [variant.get]/5)");
-    return _STD get<_Idx>(_Var);
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_Var);
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(variant<Types...>&) requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
 }
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(variant<_Types...>&& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx < sizeof...(_Types),
-        "get<T>(variant<Types...>&&) requires T to occur exactly once in Types. (N4950 [variant.get]/5)");
-    return _STD get<_Idx>(_STD move(_Var));
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_STD move(_Var));
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(variant<Types...>&&) requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
 }
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(const variant<_Types...>& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx < sizeof...(_Types),
-        "get<T>(const variant<Types...>&) requires T to occur exactly once in Types. (N4950 [variant.get]/5)");
-    return _STD get<_Idx>(_Var);
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_Var);
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(const variant<Types...>&) requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
 }
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr decltype(auto) get(const variant<_Types...>&& _Var) {
     // access the contained value of _Var if its alternative _Ty is active
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx < sizeof...(_Types),
-        "get<T>(const variant<Types...>&&) requires T to occur exactly once in Types. (N4950 [variant.get]/5)");
-    return _STD get<_Idx>(_STD move(_Var));
+    if constexpr (_Idx < sizeof...(_Types)) {
+        return _STD get<_Idx>(_STD move(_Var));
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get<T>(const variant<Types...>&&) requires T to occur exactly once in Types. (N4971 [variant.get]/8)");
+    }
 }
 
 _EXPORT_STD template <size_t _Idx, class... _Types>
@@ -1275,17 +1251,23 @@ _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr add_pointer_t<_Ty> get_if(variant<_Types...>* _Ptr) noexcept {
     // get the address of *_Ptr's contained value if it holds alternative _Ty
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx != _Meta_npos,
-        "get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4950 [variant.get]/9)");
-    return _STD get_if<_Idx>(_Ptr);
+    if constexpr (_Idx != _Meta_npos) {
+        return _STD get_if<_Idx>(_Ptr);
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get_if<T>(variant<Types...> *) requires T to occur exactly once in Types. (N4971 [variant.get]/12)");
+    }
 }
 _EXPORT_STD template <class _Ty, class... _Types>
 _NODISCARD constexpr add_pointer_t<const _Ty> get_if(const variant<_Types...>* _Ptr) noexcept {
     // get the address of *_Ptr's contained value if it holds alternative _Ty
     constexpr size_t _Idx = _Meta_find_unique_index<variant<_Types...>, _Ty>::value;
-    static_assert(_Idx != _Meta_npos,
-        "get_if<T>(const variant<Types...> *) requires T to occur exactly once in Types. (N4950 [variant.get]/9)");
-    return _STD get_if<_Idx>(_Ptr);
+    if constexpr (_Idx != _Meta_npos) {
+        return _STD get_if<_Idx>(_Ptr);
+    } else {
+        static_assert(_Always_false<_Ty>,
+            "get_if<T>(const variant<Types...> *) requires T to occur exactly once in Types. (N4971 [variant.get]/12)");
+    }
 }
 
 template <class _Op, class _Result, class... _Types>