diff --git a/stl/inc/algorithm b/stl/inc/algorithm
index ff1f8b65e3..29672ceb0f 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 f2e0482894..6e96021217 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 1c5fc74e80..321dd09ebe 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"