_STD -> _VSTD to avoid macro clash on windows

llvm-svn: 134190

1 files changed, 192 insertions, 192 deletions

diff --git a/libcxx/include/algorithm b/libcxx/include/algorithm
index 4789b0bb2a1..3e0938fe2ea 100644
--- a/libcxx/include/algorithm
+++ b/libcxx/include/algorithm
@@ -757,7 +757,7 @@ for_each(_InputIterator __first, _InputIterator __last, _Function __f)
 {
     for (; __first != __last; ++__first)
         __f(*__first);
-    return _STD::move(__f);
+    return _VSTD::move(__f);
 }
 
 // find
@@ -929,7 +929,7 @@ _ForwardIterator1
 find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
          _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
 {
-    return _STD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
+    return _VSTD::__find_end<typename add_lvalue_reference<_BinaryPredicate>::type>
                          (__first1, __last1, __first2, __last2, __pred,
                           typename iterator_traits<_ForwardIterator1>::iterator_category(),
                           typename iterator_traits<_ForwardIterator2>::iterator_category());
@@ -943,7 +943,7 @@ find_end(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 {
     typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
     typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
-    return _STD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
+    return _VSTD::find_end(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
 }
 
 // find_first_of
@@ -968,7 +968,7 @@ find_first_of(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 {
     typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
     typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
-    return _STD::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
+    return _VSTD::find_first_of(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
 }
 
 // adjacent_find
@@ -997,7 +997,7 @@ _ForwardIterator
 adjacent_find(_ForwardIterator __first, _ForwardIterator __last)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type __v;
-    return _STD::adjacent_find(__first, __last, __equal_to<__v>());
+    return _VSTD::adjacent_find(__first, __last, __equal_to<__v>());
 }
 
 // count
@@ -1049,7 +1049,7 @@ mismatch(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __fi
 {
     typedef typename iterator_traits<_InputIterator1>::value_type __v1;
     typedef typename iterator_traits<_InputIterator2>::value_type __v2;
-    return _STD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
+    return _VSTD::mismatch(__first1, __last1, __first2, __equal_to<__v1, __v2>());
 }
 
 // equal
@@ -1072,7 +1072,7 @@ equal(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first
 {
     typedef typename iterator_traits<_InputIterator1>::value_type __v1;
     typedef typename iterator_traits<_InputIterator2>::value_type __v2;
-    return _STD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
+    return _VSTD::equal(__first1, __last1, __first2, __equal_to<__v1, __v2>());
 }
 
 // is_permutation
@@ -1090,10 +1090,10 @@ is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 __not_done:
     // __first1 != __last1 && *__first1 != *__first2
     typedef typename iterator_traits<_ForwardIterator1>::difference_type _D1;
-    _D1 __l1 = _STD::distance(__first1, __last1);
+    _D1 __l1 = _VSTD::distance(__first1, __last1);
     if (__l1 == _D1(1))
         return false;
-    _ForwardIterator2 __last2 = _STD::next(__first2, __l1);
+    _ForwardIterator2 __last2 = _VSTD::next(__first2, __l1);
     // For each element in [f1, l1) see if there are the same number of
     //    equal elements in [f2, l2)
     for (_ForwardIterator1 __i = __first1; __i != __last1; ++__i)
@@ -1112,7 +1112,7 @@ __not_done:
                 return false;
             // Count number of *__i in [__i, l1) (we can start with 1)
             _D1 __c1 = 1;
-            for (_ForwardIterator1 __j = _STD::next(__i); __j != __last1; ++__j)
+            for (_ForwardIterator1 __j = _VSTD::next(__i); __j != __last1; ++__j)
                 if (__pred(*__i, *__j))
                     ++__c1;
             if (__c1 != __c2)
@@ -1131,7 +1131,7 @@ is_permutation(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 {
     typedef typename iterator_traits<_ForwardIterator1>::value_type __v1;
     typedef typename iterator_traits<_ForwardIterator2>::value_type __v2;
-    return _STD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
+    return _VSTD::is_permutation(__first1, __last1, __first2, __equal_to<__v1, __v2>());
 }
 
 // search
@@ -1291,7 +1291,7 @@ _ForwardIterator1
 search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
        _ForwardIterator2 __first2, _ForwardIterator2 __last2, _BinaryPredicate __pred)
 {
-    return _STD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
+    return _VSTD::__search<typename add_lvalue_reference<_BinaryPredicate>::type>
                          (__first1, __last1, __first2, __last2, __pred,
                           typename std::iterator_traits<_ForwardIterator1>::iterator_category(),
                           typename std::iterator_traits<_ForwardIterator2>::iterator_category());
@@ -1305,7 +1305,7 @@ search(_ForwardIterator1 __first1, _ForwardIterator1 __last1,
 {
     typedef typename std::iterator_traits<_ForwardIterator1>::value_type __v1;
     typedef typename std::iterator_traits<_ForwardIterator2>::value_type __v2;
-    return _STD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
+    return _VSTD::search(__first1, __last1, __first2, __last2, __equal_to<__v1, __v2>());
 }
 
 // search_n
@@ -1393,7 +1393,7 @@ _ForwardIterator
 search_n(_ForwardIterator __first, _ForwardIterator __last,
          _Size __count, const _Tp& __value, _BinaryPredicate __pred)
 {
-    return _STD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
+    return _VSTD::__search_n<typename add_lvalue_reference<_BinaryPredicate>::type>
            (__first, __last, __count, __value, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
 }
 
@@ -1403,7 +1403,7 @@ _ForwardIterator
 search_n(_ForwardIterator __first, _ForwardIterator __last, _Size __count, const _Tp& __value)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type __v;
-    return _STD::search_n(__first, __last, __count, __value, __equal_to<__v, _Tp>());
+    return _VSTD::search_n(__first, __last, __count, __value, __equal_to<__v, _Tp>());
 }
 
 // copy
@@ -1479,7 +1479,7 @@ typename enable_if
 __copy(_Tp* __first, _Tp* __last, _Up* __result)
 {
     const size_t __n = static_cast<size_t>(__last - __first);
-    _STD::memmove(__result, __first, __n * sizeof(_Up));
+    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
     return __result + __n;
 }
 
@@ -1488,7 +1488,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    return _STD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    return _VSTD::__copy(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
 }
 
 // copy_backward
@@ -1515,7 +1515,7 @@ __copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
 {
     const size_t __n = static_cast<size_t>(__last - __first);
     __result -= __n;
-    _STD::memmove(__result, __first, __n * sizeof(_Up));
+    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
     return __result;
 }
 
@@ -1525,7 +1525,7 @@ _BidirectionalIterator2
 copy_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    return _STD::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    return _VSTD::__copy_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
 }
 
 // copy_if
@@ -1582,7 +1582,7 @@ typename enable_if
 >::type
 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
 {
-    return _STD::copy(__first, __first + __n, __result);
+    return _VSTD::copy(__first, __first + __n, __result);
 }
 
 // move
@@ -1593,7 +1593,7 @@ _OutputIterator
 __move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     for (; __first != __last; ++__first, ++__result)
-        *__result = _STD::move(*__first);
+        *__result = _VSTD::move(*__first);
     return __result;
 }
 
@@ -1608,7 +1608,7 @@ typename enable_if
 __move(_Tp* __first, _Tp* __last, _Up* __result)
 {
     const size_t __n = static_cast<size_t>(__last - __first);
-    _STD::memmove(__result, __first, __n * sizeof(_Up));
+    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
     return __result + __n;
 }
 
@@ -1617,7 +1617,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 move(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
-    return _STD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    return _VSTD::__move(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
 }
 
 // move_backward
@@ -1628,7 +1628,7 @@ _OutputIterator
 __move_backward(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     while (__first != __last)
-        *--__result = _STD::move(*--__last);
+        *--__result = _VSTD::move(*--__last);
     return __result;
 }
 
@@ -1644,7 +1644,7 @@ __move_backward(_Tp* __first, _Tp* __last, _Up* __result)
 {
     const size_t __n = static_cast<size_t>(__last - __first);
     __result -= __n;
-    _STD::memmove(__result, __first, __n * sizeof(_Up));
+    _VSTD::memmove(__result, __first, __n * sizeof(_Up));
     return __result;
 }
 
@@ -1654,7 +1654,7 @@ _BidirectionalIterator2
 move_backward(_BidirectionalIterator1 __first, _BidirectionalIterator1 __last,
               _BidirectionalIterator2 __result)
 {
-    return _STD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
+    return _VSTD::__move_backward(__unwrap_iter(__first), __unwrap_iter(__last), __unwrap_iter(__result));
 }
 
 // iter_swap
@@ -1758,7 +1758,7 @@ _OutputIterator
 __fill_n(_OutputIterator __first, _Size __n, const _Tp& __value, true_type)
 {
     if (__n > 0)
-        _STD::memset(__first, (unsigned char)__value, (size_t)(__n));
+        _VSTD::memset(__first, (unsigned char)__value, (size_t)(__n));
     return __first + __n;
 }
 
@@ -1767,7 +1767,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
 {
-   return _STD::__fill_n(__first, __n, __value, integral_constant<bool,
+   return _VSTD::__fill_n(__first, __n, __value, integral_constant<bool,
                                               is_pointer<_OutputIterator>::value &&
                                               is_trivially_copy_assignable<_Tp>::value     &&
                                               sizeof(_Tp) == 1>());
@@ -1789,7 +1789,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 __fill(_RandomAccessIterator __first, _RandomAccessIterator __last, const _Tp& __value, random_access_iterator_tag)
 {
-    _STD::fill_n(__first, __last - __first, __value);
+    _VSTD::fill_n(__first, __last - __first, __value);
 }
 
 template <class _ForwardIterator, class _Tp>
@@ -1797,7 +1797,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    _STD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
+    _VSTD::__fill(__first, __last, __value, typename iterator_traits<_ForwardIterator>::iterator_category());
 }
 
 // generate
@@ -1829,7 +1829,7 @@ template <class _ForwardIterator, class _Tp>
 _ForwardIterator
 remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    __first = _STD::find(__first, __last, __value);
+    __first = _VSTD::find(__first, __last, __value);
     if (__first != __last)
     {
         _ForwardIterator __i = __first;
@@ -1837,7 +1837,7 @@ remove(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
         {
             if (!(*__i == __value))
             {
-                *__first = _STD::move(*__i);
+                *__first = _VSTD::move(*__i);
                 ++__first;
             }
         }
@@ -1851,7 +1851,7 @@ template <class _ForwardIterator, class _Predicate>
 _ForwardIterator
 remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 {
-    __first = _STD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
+    __first = _VSTD::find_if<_ForwardIterator, typename add_lvalue_reference<_Predicate>::type>
                            (__first, __last, __pred);
     if (__first != __last)
     {
@@ -1860,7 +1860,7 @@ remove_if(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
         {
             if (!__pred(*__i))
             {
-                *__first = _STD::move(*__i);
+                *__first = _VSTD::move(*__i);
                 ++__first;
             }
         }
@@ -1910,7 +1910,7 @@ template <class _ForwardIterator, class _BinaryPredicate>
 _ForwardIterator
 unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pred)
 {
-    __first = _STD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
+    __first = _VSTD::adjacent_find<_ForwardIterator, typename add_lvalue_reference<_BinaryPredicate>::type>
                                  (__first, __last, __pred);
     if (__first != __last)
     {
@@ -1919,7 +1919,7 @@ unique(_ForwardIterator __first, _ForwardIterator __last, _BinaryPredicate __pre
         _ForwardIterator __i = __first;
         for (++__i; ++__i != __last;)
             if (!__pred(*__first, *__i))
-                *++__first = _STD::move(*__i);
+                *++__first = _VSTD::move(*__i);
         ++__first;
     }
     return __first;
@@ -1931,7 +1931,7 @@ _ForwardIterator
 unique(_ForwardIterator __first, _ForwardIterator __last)
 {
     typedef typename iterator_traits<_ForwardIterator>::value_type __v;
-    return _STD::unique(__first, __last, __equal_to<__v>());
+    return _VSTD::unique(__first, __last, __equal_to<__v>());
 }
 
 // unique_copy
@@ -2003,7 +2003,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result, _BinaryPredicate __pred)
 {
-    return _STD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
+    return _VSTD::__unique_copy<typename add_lvalue_reference<_BinaryPredicate>::type>
                               (__first, __last, __result, __pred,
                                typename iterator_traits<_InputIterator>::iterator_category(),
                                typename iterator_traits<_OutputIterator>::iterator_category());
@@ -2015,7 +2015,7 @@ _OutputIterator
 unique_copy(_InputIterator __first, _InputIterator __last, _OutputIterator __result)
 {
     typedef typename iterator_traits<_InputIterator>::value_type __v;
-    return _STD::unique_copy(__first, __last, __result, __equal_to<__v>());
+    return _VSTD::unique_copy(__first, __last, __result, __equal_to<__v>());
 }
 
 // reverse
@@ -2049,7 +2049,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 reverse(_BidirectionalIterator __first, _BidirectionalIterator __last)
 {
-    _STD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
+    _VSTD::__reverse(__first, __last, typename iterator_traits<_BidirectionalIterator>::iterator_category());
 }
 
 // reverse_copy
@@ -2134,7 +2134,7 @@ __rotate(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomA
     const difference_type __m2 = __last - __middle;
     if (__m1 == __m2)
     {
-        _STD::swap_ranges(__first, __middle, __middle);
+        _VSTD::swap_ranges(__first, __middle, __middle);
         return __middle;
     }
     const difference_type __g = __gcd(__m1, __m2);
@@ -2163,7 +2163,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last)
 {
-    return _STD::__rotate(__first, __middle, __last,
+    return _VSTD::__rotate(__first, __middle, __last,
                           integral_constant
                           <
                                bool,
@@ -2186,7 +2186,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _OutputIterator
 rotate_copy(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __last, _OutputIterator __result)
 {
-    return _STD::copy(__first, __middle, _STD::copy(__middle, __last, __result));
+    return _VSTD::copy(__first, __middle, _VSTD::copy(__middle, __last, __result));
 }
 
 // min_element
@@ -2211,7 +2211,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 min_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::min_element(__first, __last,
+    return _VSTD::min_element(__first, __last,
               __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
@@ -2230,7 +2230,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 const _Tp&
 min(const _Tp& __a, const _Tp& __b)
 {
-    return _STD::min(__a, __b, __less<_Tp>());
+    return _VSTD::min(__a, __b, __less<_Tp>());
 }
 
 template<class _Tp, class _Compare>
@@ -2238,7 +2238,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 min(initializer_list<_Tp> __t, _Compare __comp)
 {
-    return *_STD::min_element(__t.begin(), __t.end(), __comp);
+    return *_VSTD::min_element(__t.begin(), __t.end(), __comp);
 }
 
 template<class _Tp>
@@ -2246,7 +2246,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 min(initializer_list<_Tp> __t)
 {
-    return *_STD::min_element(__t.begin(), __t.end());
+    return *_VSTD::min_element(__t.begin(), __t.end());
 }
 
 // max_element
@@ -2271,7 +2271,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 max_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::max_element(__first, __last,
+    return _VSTD::max_element(__first, __last,
               __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
@@ -2290,7 +2290,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 const _Tp&
 max(const _Tp& __a, const _Tp& __b)
 {
-    return _STD::max(__a, __b, __less<_Tp>());
+    return _VSTD::max(__a, __b, __less<_Tp>());
 }
 
 template<class _Tp, class _Compare>
@@ -2298,7 +2298,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 max(initializer_list<_Tp> __t, _Compare __comp)
 {
-    return *_STD::max_element(__t.begin(), __t.end(), __comp);
+    return *_VSTD::max_element(__t.begin(), __t.end(), __comp);
 }
 
 template<class _Tp>
@@ -2306,7 +2306,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _Tp
 max(initializer_list<_Tp> __t)
 {
-    return *_STD::max_element(__t.begin(), __t.end());
+    return *_VSTD::max_element(__t.begin(), __t.end());
 }
 
 // minmax_element
@@ -2366,7 +2366,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 std::pair<_ForwardIterator, _ForwardIterator>
 minmax_element(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+    return _VSTD::minmax_element(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // minmax
@@ -2385,7 +2385,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 pair<const _Tp&, const _Tp&>
 minmax(const _Tp& __a, const _Tp& __b)
 {
-    return _STD::minmax(__a, __b, __less<_Tp>());
+    return _VSTD::minmax(__a, __b, __less<_Tp>());
 }
 
 template<class _Tp>
@@ -2394,7 +2394,7 @@ pair<_Tp, _Tp>
 minmax(initializer_list<_Tp> __t)
 {
     pair<const _Tp*, const _Tp*> __p =
-                                   _STD::minmax_element(__t.begin(), __t.end());
+                                   _VSTD::minmax_element(__t.begin(), __t.end());
     return pair<_Tp, _Tp>(*__p.first, *__p.second);
 }
 
@@ -2404,7 +2404,7 @@ pair<_Tp, _Tp>
 minmax(initializer_list<_Tp> __t, _Compare __comp)
 {
     pair<const _Tp*, const _Tp*> __p =
-                           _STD::minmax_element(__t.begin(), __t.end(), __comp);
+                           _VSTD::minmax_element(__t.begin(), __t.end(), __comp);
     return pair<_Tp, _Tp>(*__p.first, *__p.second);
 }
 
@@ -2810,7 +2810,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 {
-    return _STD::__partition<typename add_lvalue_reference<_Predicate>::type>
+    return _VSTD::__partition<typename add_lvalue_reference<_Predicate>::type>
                             (__first, __last, __pred, typename iterator_traits<_ForwardIterator>::iterator_category());
 }
 
@@ -2846,12 +2846,12 @@ _ForwardIterator
 partition_point(_ForwardIterator __first, _ForwardIterator __last, _Predicate __pred)
 {
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
-    difference_type __len = _STD::distance(__first, __last);
+    difference_type __len = _VSTD::distance(__first, __last);
     while (__len != 0)
     {
         difference_type __l2 = __len / 2;
         _ForwardIterator __m = __first;
-        _STD::advance(__m, __l2);
+        _VSTD::advance(__m, __l2);
         if (__pred(*__m))
         {
             __first = ++__m;
@@ -2892,7 +2892,7 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
         // Move the falses into the temporary buffer, and the trues to the front of the line
         // Update __first to always point to the end of the trues
         value_type* __t = __p.first;
-        ::new(__t) value_type(_STD::move(*__first));
+        ::new(__t) value_type(_VSTD::move(*__first));
         __d.__incr((value_type*)0);
         ++__t;
         _ForwardIterator __i = __first;
@@ -2900,12 +2900,12 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
         {
             if (__pred(*__i))
             {
-                *__first = _STD::move(*__i);
+                *__first = _VSTD::move(*__i);
                 ++__first;
             }
             else
             {
-                ::new(__t) value_type(_STD::move(*__i));
+                ::new(__t) value_type(_VSTD::move(*__i));
                 __d.__incr((value_type*)0);
                 ++__t;
             }
@@ -2914,7 +2914,7 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
         // Move falses back into range, but don't mess up __first which points to first false
         __i = __first;
         for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
-            *__i = _STD::move(*__t2);
+            *__i = _VSTD::move(*__t2);
         // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
         return __first;
     }
@@ -2922,7 +2922,7 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
     // __len >= 3
     _ForwardIterator __m = __first;
     _Distance __len2 = __len / 2;  // __len2 >= 2
-    _STD::advance(__m, __len2);
+    _VSTD::advance(__m, __len2);
     // recurse on [__first, __m), *__first know to be false
     // F?????????????????
     // f       m         l
@@ -2946,7 +2946,7 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
 __second_half_done:
     // TTTFFFFFTTTTTFFFFF
     // f  ff   m    sf   l
-    return _STD::rotate(__first_false, __m, __second_false);
+    return _VSTD::rotate(__first_false, __m, __second_false);
     // TTTTTTTTFFFFFFFFFF
     //         |
 }
@@ -2954,7 +2954,7 @@ __second_half_done:
 struct __return_temporary_buffer
 {
     template <class _Tp>
-    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_STD::return_temporary_buffer(__p);}
+    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p) const {_VSTD::return_temporary_buffer(__p);}
 };
 
 template <class _Predicate, class _ForwardIterator>
@@ -2976,12 +2976,12 @@ __stable_partition(_ForwardIterator __first, _ForwardIterator __last, _Predicate
     // *__first is known to be false
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
     typedef typename iterator_traits<_ForwardIterator>::value_type value_type;
-    difference_type __len = _STD::distance(__first, __last);
+    difference_type __len = _VSTD::distance(__first, __last);
     pair<value_type*, ptrdiff_t> __p(0, 0);
     unique_ptr<value_type, __return_temporary_buffer> __h;
     if (__len >= __alloc_limit)
     {
-        __p = _STD::get_temporary_buffer<value_type>(__len);
+        __p = _VSTD::get_temporary_buffer<value_type>(__len);
         __h.reset(__p.first);
     }
     return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
@@ -3022,7 +3022,7 @@ __stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last
         // Move the falses into the temporary buffer, and the trues to the front of the line
         // Update __first to always point to the end of the trues
         value_type* __t = __p.first;
-        ::new(__t) value_type(_STD::move(*__first));
+        ::new(__t) value_type(_VSTD::move(*__first));
         __d.__incr((value_type*)0);
         ++__t;
         _BidirectionalIterator __i = __first;
@@ -3030,23 +3030,23 @@ __stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last
         {
             if (__pred(*__i))
             {
-                *__first = _STD::move(*__i);
+                *__first = _VSTD::move(*__i);
                 ++__first;
             }
             else
             {
-                ::new(__t) value_type(_STD::move(*__i));
+                ::new(__t) value_type(_VSTD::move(*__i));
                 __d.__incr((value_type*)0);
                 ++__t;
             }
         }
         // move *__last, known to be true
-        *__first = _STD::move(*__i);
+        *__first = _VSTD::move(*__i);
         __i = ++__first;
         // All trues now at start of range, all falses in buffer
         // Move falses back into range, but don't mess up __first which points to first false
         for (value_type* __t2 = __p.first; __t2 < __t; ++__t2, ++__i)
-            *__i = _STD::move(*__t2);
+            *__i = _VSTD::move(*__t2);
         // __h destructs moved-from values out of the temp buffer, but doesn't deallocate buffer
         return __first;
     }
@@ -3054,7 +3054,7 @@ __stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last
     // __len >= 4
     _BidirectionalIterator __m = __first;
     _Distance __len2 = __len / 2;  // __len2 >= 2
-    _STD::advance(__m, __len2);
+    _VSTD::advance(__m, __len2);
     // recurse on [__first, __m-1], except reduce __m-1 until *(__m-1) is true, *__first know to be false
     // F????????????????T
     // f       m        l
@@ -3091,7 +3091,7 @@ __first_half_done:
 __second_half_done:
     // TTTFFFFFTTTTTFFFFF
     // f  ff   m    sf  l
-    return _STD::rotate(__first_false, __m, __second_false);
+    return _VSTD::rotate(__first_false, __m, __second_false);
     // TTTTTTTTFFFFFFFFFF
     //         |
 }
@@ -3124,12 +3124,12 @@ __stable_partition(_BidirectionalIterator __first, _BidirectionalIterator __last
     // *__first is known to be false
     // *__last is known to be true
     // __len >= 2
-    difference_type __len = _STD::distance(__first, __last) + 1;
+    difference_type __len = _VSTD::distance(__first, __last) + 1;
     pair<value_type*, ptrdiff_t> __p(0, 0);
     unique_ptr<value_type, __return_temporary_buffer> __h;
     if (__len >= __alloc_limit)
     {
-        __p = _STD::get_temporary_buffer<value_type>(__len);
+        __p = _VSTD::get_temporary_buffer<value_type>(__len);
         __h.reset(__p.first);
     }
     return __stable_partition<typename add_lvalue_reference<_Predicate>::type>
@@ -3169,7 +3169,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 is_sorted_until(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+    return _VSTD::is_sorted_until(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // is_sorted
@@ -3179,7 +3179,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 is_sorted(_ForwardIterator __first, _ForwardIterator __last, _Compare __comp)
 {
-    return _STD::is_sorted_until(__first, __last, __comp) == __last;
+    return _VSTD::is_sorted_until(__first, __last, __comp) == __last;
 }
 
 template<class _ForwardIterator>
@@ -3187,7 +3187,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 is_sorted(_ForwardIterator __first, _ForwardIterator __last)
 {
-    return _STD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
+    return _VSTD::is_sorted(__first, __last, __less<typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
 // sort
@@ -3294,7 +3294,7 @@ __selection_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last
     _BirdirectionalIterator __lm1 = __last;
     for (--__lm1; __first != __lm1; ++__first)
     {
-        _BirdirectionalIterator __i = _STD::min_element<_BirdirectionalIterator,
+        _BirdirectionalIterator __i = _VSTD::min_element<_BirdirectionalIterator,
                                                         typename add_lvalue_reference<_Compare>::type>
                                                        (__first, __last, __comp);
         if (__i != __first)
@@ -3313,10 +3313,10 @@ __insertion_sort(_BirdirectionalIterator __first, _BirdirectionalIterator __last
         for (++__i; __i != __last; ++__i)
         {
             _BirdirectionalIterator __j = __i;
-            value_type __t(_STD::move(*__j));
+            value_type __t(_VSTD::move(*__j));
             for (_BirdirectionalIterator __k = __i; __k != __first && __comp(__t,  *--__k); --__j)
-                *__j = _STD::move(*__k);
-            *__j = _STD::move(__t);
+                *__j = _VSTD::move(*__k);
+            *__j = _VSTD::move(__t);
         }
     }
 }
@@ -3332,15 +3332,15 @@ __insertion_sort_3(_RandomAccessIterator __first, _RandomAccessIterator __last,
     {
         if (__comp(*__i, *__j))
         {
-            value_type __t(_STD::move(*__i));
+            value_type __t(_VSTD::move(*__i));
             _RandomAccessIterator __k = __j;
             __j = __i;
             do
             {
-                *__j = _STD::move(*__k);
+                *__j = _VSTD::move(*__k);
                 __j = __k;
             } while (__j != __first && __comp(__t, *--__k));
-            *__j = _STD::move(__t);
+            *__j = _VSTD::move(__t);
         }
         __j = __i;
     }
@@ -3360,13 +3360,13 @@ __insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator
             swap(*__first, *__last);
         return true;
     case 3:
-        _STD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
+        _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
         return true;
     case 4:
-        _STD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
+        _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
         return true;
     case 5:
-        _STD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
+        _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
         return true;
     }
     typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
@@ -3378,15 +3378,15 @@ __insertion_sort_incomplete(_RandomAccessIterator __first, _RandomAccessIterator
     {
         if (__comp(*__i, *__j))
         {
-            value_type __t(_STD::move(*__i));
+            value_type __t(_VSTD::move(*__i));
             _RandomAccessIterator __k = __j;
             __j = __i;
             do
             {
-                *__j = _STD::move(*__k);
+                *__j = _VSTD::move(*__k);
                 __j = __k;
             } while (__j != __first && __comp(__t, *--__k));
-            *__j = _STD::move(__t);
+            *__j = _VSTD::move(__t);
             if (++__count == __limit)
                 return ++__i == __last;
         }
@@ -3406,7 +3406,7 @@ __insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator
         __destruct_n __d(0);
         unique_ptr<value_type, __destruct_n&> __h(__first2, __d);
         value_type* __last2 = __first2;
-        ::new(__last2) value_type(_STD::move(*__first1));
+        ::new(__last2) value_type(_VSTD::move(*__first1));
         __d.__incr((value_type*)0);
         for (++__last2; ++__first1 != __last1; ++__last2)
         {
@@ -3414,15 +3414,15 @@ __insertion_sort_move(_BirdirectionalIterator __first1, _BirdirectionalIterator
             value_type* __i2 = __j2;
             if (__comp(*__first1, *--__i2))
             {
-                ::new(__j2) value_type(_STD::move(*__i2));
+                ::new(__j2) value_type(_VSTD::move(*__i2));
                 __d.__incr((value_type*)0);
                 for (--__j2; __i2 != __first2 && __comp(*__first1,  *--__i2); --__j2)
-                    *__j2 = _STD::move(*__i2);
-                *__j2 = _STD::move(*__first1);
+                    *__j2 = _VSTD::move(*__i2);
+                *__j2 = _VSTD::move(*__first1);
             }
             else
             {
-                ::new(__j2) value_type(_STD::move(*__first1));
+                ::new(__j2) value_type(_VSTD::move(*__first1));
                 __d.__incr((value_type*)0);
             }
         }
@@ -3453,18 +3453,18 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
                 swap(*__first, *__last);
             return;
         case 3:
-            _STD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
+            _VSTD::__sort3<_Compare>(__first, __first+1, --__last, __comp);
             return;
         case 4:
-            _STD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
+            _VSTD::__sort4<_Compare>(__first, __first+1, __first+2, --__last, __comp);
             return;
         case 5:
-            _STD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
+            _VSTD::__sort5<_Compare>(__first, __first+1, __first+2, __first+3, --__last, __comp);
             return;
         }
         if (__len <= __limit)
         {
-            _STD::__insertion_sort_3<_Compare>(__first, __last, __comp);
+            _VSTD::__insertion_sort_3<_Compare>(__first, __last, __comp);
             return;
         }
         // __len > 5
@@ -3479,13 +3479,13 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
             __delta = __len/2;
             __m += __delta;
             __delta /= 2;
-            __n_swaps = _STD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
+            __n_swaps = _VSTD::__sort5<_Compare>(__first, __first + __delta, __m, __m+__delta, __lm1, __comp);
         }
         else
         {
             __delta = __len/2;
             __m += __delta;
-            __n_swaps = _STD::__sort3<_Compare>(__first, __m, __lm1, __comp);
+            __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, __lm1, __comp);
         }
         }
         // *__m is median
@@ -3541,7 +3541,7 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
                     }
                     // [__first, __i) == *__first and *__first < [__i, __last)
                     // The first part is sorted, sort the secod part
-                    // _STD::__sort<_Compare>(__i, __last, __comp);
+                    // _VSTD::__sort<_Compare>(__i, __last, __comp);
                     __first = __i;
                     goto __restart;
                 }
@@ -3590,8 +3590,8 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
         // If we were given a perfect partition, see if insertion sort is quick...
         if (__n_swaps == 0)
         {
-            bool __fs = _STD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
-            if (_STD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
+            bool __fs = _VSTD::__insertion_sort_incomplete<_Compare>(__first, __i, __comp);
+            if (_VSTD::__insertion_sort_incomplete<_Compare>(__i+1, __last, __comp))
             {
                 if (__fs)
                     return;
@@ -3610,14 +3610,14 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
         // sort smaller range with recursive call and larger with tail recursion elimination
         if (__i - __first < __last - __i)
         {
-            _STD::__sort<_Compare>(__first, __i, __comp);
-            // _STD::__sort<_Compare>(__i+1, __last, __comp);
+            _VSTD::__sort<_Compare>(__first, __i, __comp);
+            // _VSTD::__sort<_Compare>(__i+1, __last, __comp);
             __first = ++__i;
         }
         else
         {
-            _STD::__sort<_Compare>(__i+1, __last, __comp);
-            // _STD::__sort<_Compare>(__first, __i, __comp);
+            _VSTD::__sort<_Compare>(__i+1, __last, __comp);
+            // _VSTD::__sort<_Compare>(__first, __i, __comp);
             __last = __i;
         }
     }
@@ -3644,7 +3644,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    _STD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 template <class _Tp>
@@ -3652,7 +3652,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 sort(_Tp** __first, _Tp** __last)
 {
-    _STD::sort((size_t*)__first, (size_t*)__last, __less<size_t>());
+    _VSTD::sort((size_t*)__first, (size_t*)__last, __less<size_t>());
 }
 
 template <class _Tp>
@@ -3660,7 +3660,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 sort(__wrap_iter<_Tp*> __first, __wrap_iter<_Tp*> __last)
 {
-    _STD::sort(__first.base(), __last.base());
+    _VSTD::sort(__first.base(), __last.base());
 }
 
 extern template void __sort<__less<char>&, char*>(char*, char*, __less<char>&);
@@ -3704,12 +3704,12 @@ _ForwardIterator
 __lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
-    difference_type __len = _STD::distance(__first, __last);
+    difference_type __len = _VSTD::distance(__first, __last);
     while (__len != 0)
     {
         difference_type __l2 = __len / 2;
         _ForwardIterator __m = __first;
-        _STD::advance(__m, __l2);
+        _VSTD::advance(__m, __l2);
         if (__comp(*__m, __value))
         {
             __first = ++__m;
@@ -3741,7 +3741,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 lower_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return _STD::lower_bound(__first, __last, __value,
+    return _VSTD::lower_bound(__first, __last, __value,
                              __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
 }
 
@@ -3752,12 +3752,12 @@ _ForwardIterator
 __upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
-    difference_type __len = _STD::distance(__first, __last);
+    difference_type __len = _VSTD::distance(__first, __last);
     while (__len != 0)
     {
         difference_type __l2 = __len / 2;
         _ForwardIterator __m = __first;
-        _STD::advance(__m, __l2);
+        _VSTD::advance(__m, __l2);
         if (__comp(__value, *__m))
             __len = __l2;
         else
@@ -3789,7 +3789,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _ForwardIterator
 upper_bound(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return _STD::upper_bound(__first, __last, __value,
+    return _VSTD::upper_bound(__first, __last, __value,
                              __less<_Tp, typename iterator_traits<_ForwardIterator>::value_type>());
 }
 
@@ -3800,12 +3800,12 @@ pair<_ForwardIterator, _ForwardIterator>
 __equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value, _Compare __comp)
 {
     typedef typename iterator_traits<_ForwardIterator>::difference_type difference_type;
-    difference_type __len = _STD::distance(__first, __last);
+    difference_type __len = _VSTD::distance(__first, __last);
     while (__len != 0)
     {
         difference_type __l2 = __len / 2;
         _ForwardIterator __m = __first;
-        _STD::advance(__m, __l2);
+        _VSTD::advance(__m, __l2);
         if (__comp(*__m, __value))
         {
             __first = ++__m;
@@ -3849,7 +3849,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 pair<_ForwardIterator, _ForwardIterator>
 equal_range(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return _STD::equal_range(__first, __last, __value,
+    return _VSTD::equal_range(__first, __last, __value,
                              __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
 }
 
@@ -3884,7 +3884,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 binary_search(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value)
 {
-    return _STD::binary_search(__first, __last, __value,
+    return _VSTD::binary_search(__first, __last, __value,
                              __less<typename iterator_traits<_ForwardIterator>::value_type, _Tp>());
 }
 
@@ -3898,7 +3898,7 @@ __merge(_InputIterator1 __first1, _InputIterator1 __last1,
     for (; __first1 != __last1; ++__result)
     {
         if (__first2 == __last2)
-            return _STD::copy(__first1, __last1, __result);
+            return _VSTD::copy(__first1, __last1, __result);
         if (__comp(*__first2, *__first1))
         {
             *__result = *__first2;
@@ -3910,7 +3910,7 @@ __merge(_InputIterator1 __first1, _InputIterator1 __last1,
             ++__first1;
         }
     }
-    return _STD::copy(__first2, __last2, __result);
+    return _VSTD::copy(__first2, __last2, __result);
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
@@ -3922,10 +3922,10 @@ merge(_InputIterator1 __first1, _InputIterator1 __last1,
 #ifdef _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
-    return _STD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
+    return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __c);
 #else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
-    return _STD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
+    return _VSTD::__merge<_Comp_ref>(__first1, __last1, __first2, __last2, __result, __comp);
 #endif  // _LIBCPP_DEBUG
 }
 
@@ -3958,7 +3958,7 @@ __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator
     {
         value_type* __p = __buff;
         for (_BidirectionalIterator __i = __first; __i != __middle; __d.__incr((value_type*)0), ++__i, ++__p)
-            ::new(__p) value_type(_STD::move(*__i));
+            ::new(__p) value_type(_VSTD::move(*__i));
         __merge<_Compare>(move_iterator<value_type*>(__buff),
                           move_iterator<value_type*>(__p),
                           move_iterator<_BidirectionalIterator>(__middle),
@@ -3969,7 +3969,7 @@ __buffered_inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator
     {
         value_type* __p = __buff;
         for (_BidirectionalIterator __i = __middle; __i != __last; __d.__incr((value_type*)0), ++__i, ++__p)
-            ::new(__p) value_type(_STD::move(*__i));
+            ::new(__p) value_type(_VSTD::move(*__i));
         typedef reverse_iterator<_BidirectionalIterator> _RBi;
         typedef reverse_iterator<value_type*> _Rv;
         __merge(move_iterator<_RBi>(_RBi(__middle)), move_iterator<_RBi>(_RBi(__first)),
@@ -4022,9 +4022,9 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle,
         {   // __len >= 1, __len2 >= 2
             __len21 = __len2 / 2;
             __m2 = __middle;
-            _STD::advance(__m2, __len21);
+            _VSTD::advance(__m2, __len21);
             __m1 = __upper_bound<_Compare>(__first, __middle, *__m2, __comp);
-            __len11 = _STD::distance(__first, __m1);
+            __len11 = _VSTD::distance(__first, __m1);
         }
         else
         {
@@ -4037,15 +4037,15 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle,
             // __len1 >= 2, __len2 >= 1
             __len11 = __len1 / 2;
             __m1 = __first;
-            _STD::advance(__m1, __len11);
+            _VSTD::advance(__m1, __len11);
             __m2 = __lower_bound<_Compare>(__middle, __last, *__m1, __comp);
-            __len21 = _STD::distance(__middle, __m2);
+            __len21 = _VSTD::distance(__middle, __m2);
         }
         difference_type __len12 = __len1 - __len11;  // distance(__m1, __middle)
         difference_type __len22 = __len2 - __len21;  // distance(__m2, __last)
         // [__first, __m1) [__m1, __middle) [__middle, __m2) [__m2, __last)
         // swap middle two partitions
-        __middle = _STD::rotate(__m1, __middle, __m2);
+        __middle = _VSTD::rotate(__m1, __middle, __m2);
         // __len12 and __len21 now have swapped meanings
         // merge smaller range with recurisve call and larger with tail recursion elimination
         if (__len11 + __len21 < __len12 + __len22)
@@ -4083,24 +4083,24 @@ inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _
 {
     typedef typename iterator_traits<_BidirectionalIterator>::value_type value_type;
     typedef typename iterator_traits<_BidirectionalIterator>::difference_type difference_type;
-    difference_type __len1 = _STD::distance(__first, __middle);
-    difference_type __len2 = _STD::distance(__middle, __last);
-    difference_type __buf_size = _STD::min(__len1, __len2);
+    difference_type __len1 = _VSTD::distance(__first, __middle);
+    difference_type __len2 = _VSTD::distance(__middle, __last);
+    difference_type __buf_size = _VSTD::min(__len1, __len2);
     pair<value_type*, ptrdiff_t> __buf(0, 0);
     unique_ptr<value_type, __return_temporary_buffer> __h;
     if (__inplace_merge_switch<value_type>::value && __buf_size > 8)
     {
-        __buf = _STD::get_temporary_buffer<value_type>(__buf_size);
+        __buf = _VSTD::get_temporary_buffer<value_type>(__buf_size);
         __h.reset(__buf.first);
     }
 #ifdef _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<__debug_less<_Compare> >::type _Comp_ref;
     __debug_less<_Compare> __c(__comp);
-    return _STD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
+    return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __c, __len1, __len2,
                                             __buf.first, __buf.second);
 #else  // _LIBCPP_DEBUG
     typedef typename add_lvalue_reference<_Compare>::type _Comp_ref;
-    return _STD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
+    return _VSTD::__inplace_merge<_Comp_ref>(__first, __middle, __last, __comp, __len1, __len2,
                                             __buf.first, __buf.second);
 #endif  // _LIBCPP_DEBUG
 }
@@ -4110,7 +4110,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle, _BidirectionalIterator __last)
 {
-    _STD::inplace_merge(__first, __middle, __last,
+    _VSTD::inplace_merge(__first, __middle, __last,
                         __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
 }
 
@@ -4130,26 +4130,26 @@ __merge_move_construct(_InputIterator1 __first1, _InputIterator1 __last1,
         if (__first1 == __last1)
         {
             for (; __first2 != __last2; ++__first2, ++__result, __d.__incr((value_type*)0))
-                ::new (__result) value_type(_STD::move(*__first2));
+                ::new (__result) value_type(_VSTD::move(*__first2));
             __h.release();
             return;
         }
         if (__first2 == __last2)
         {
             for (; __first1 != __last1; ++__first1, ++__result, __d.__incr((value_type*)0))
-                ::new (__result) value_type(_STD::move(*__first1));
+                ::new (__result) value_type(_VSTD::move(*__first1));
             __h.release();
             return;
         }
         if (__comp(*__first2, *__first1))
         {
-            ::new (__result) value_type(_STD::move(*__first2));
+            ::new (__result) value_type(_VSTD::move(*__first2));
             __d.__incr((value_type*)0);
             ++__first2;
         }
         else
         {
-            ::new (__result) value_type(_STD::move(*__first1));
+            ::new (__result) value_type(_VSTD::move(*__first1));
             __d.__incr((value_type*)0);
             ++__first1;
         }
@@ -4167,22 +4167,22 @@ __merge_move_assign(_InputIterator1 __first1, _InputIterator1 __last1,
         if (__first2 == __last2)
         {
             for (; __first1 != __last1; ++__first1, ++__result)
-                *__result = _STD::move(*__first1);
+                *__result = _VSTD::move(*__first1);
             return;
         }
         if (__comp(*__first2, *__first1))
         {
-            *__result = _STD::move(*__first2);
+            *__result = _VSTD::move(*__first2);
             ++__first2;
         }
         else
         {
-            *__result = _STD::move(*__first1);
+            *__result = _VSTD::move(*__first1);
             ++__first1;
         }
     }
     for (; __first2 != __last2; ++__first2, ++__result)
-        *__result = _STD::move(*__first2);
+        *__result = _VSTD::move(*__first2);
 }
 
 template <class _Compare, class _RandomAccessIterator>
@@ -4203,24 +4203,24 @@ __stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1
     case 0:
         return;
     case 1:
-        ::new(__first2) value_type(_STD::move(*__first1));
+        ::new(__first2) value_type(_VSTD::move(*__first1));
         return;
     case 2:
        __destruct_n __d(0);
         unique_ptr<value_type, __destruct_n&> __h2(__first2, __d);
          if (__comp(*--__last1, *__first1))
         {
-            ::new(__first2) value_type(_STD::move(*__last1));
+            ::new(__first2) value_type(_VSTD::move(*__last1));
             __d.__incr((value_type*)0);
             ++__first2;
-            ::new(__first2) value_type(_STD::move(*__first1));
+            ::new(__first2) value_type(_VSTD::move(*__first1));
         }
         else
         {
-            ::new(__first2) value_type(_STD::move(*__first1));
+            ::new(__first2) value_type(_VSTD::move(*__first1));
             __d.__incr((value_type*)0);
             ++__first2;
-            ::new(__first2) value_type(_STD::move(*__last1));
+            ::new(__first2) value_type(_VSTD::move(*__last1));
         }
         __h2.release();
         return;
@@ -4301,7 +4301,7 @@ stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compar
     unique_ptr<value_type, __return_temporary_buffer> __h;
     if (__len > static_cast<difference_type>(__stable_sort_switch<value_type>::value))
     {
-        __buf = _STD::get_temporary_buffer<value_type>(__len);
+        __buf = _VSTD::get_temporary_buffer<value_type>(__len);
         __h.reset(__buf.first);
     }
 #ifdef _LIBCPP_DEBUG
@@ -4319,7 +4319,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 stable_sort(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    _STD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::stable_sort(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // is_heap_until
@@ -4328,7 +4328,7 @@ template <class _RandomAccessIterator, class _Compare>
 _RandomAccessIterator
 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-    typedef typename _STD::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
+    typedef typename _VSTD::iterator_traits<_RandomAccessIterator>::difference_type difference_type;
     difference_type __len = __last - __first;
     difference_type __p = 0;
     difference_type __c = 1;
@@ -4356,7 +4356,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _RandomAccessIterator
 is_heap_until(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    return _STD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    return _VSTD::is_heap_until(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // is_heap
@@ -4366,7 +4366,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __comp)
 {
-    return _STD::is_heap_until(__first, __last, __comp) == __last;
+    return _VSTD::is_heap_until(__first, __last, __comp) == __last;
 }
 
 template<class _RandomAccessIterator>
@@ -4374,7 +4374,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 is_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    return _STD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    return _VSTD::is_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // push_heap
@@ -4399,10 +4399,10 @@ __push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare
         }
         if (__comp(*__pp, *__cp))
         {
-            value_type __t(_STD::move(*__pp));
+            value_type __t(_VSTD::move(*__pp));
             do
             {
-                *__pp = _STD::move(*__cp);
+                *__pp = _VSTD::move(*__cp);
                 __pp = __cp;
                 __p = __c;
                 __c = (__p + 1) * 2;
@@ -4415,7 +4415,7 @@ __push_heap_front(_RandomAccessIterator __first, _RandomAccessIterator, _Compare
                     --__cp;
                 }
             } while (__comp(__t, *__cp));
-            *__pp = _STD::move(__t);
+            *__pp = _VSTD::move(__t);
         }
     }
 }
@@ -4433,17 +4433,17 @@ __push_heap_back(_RandomAccessIterator __first, _RandomAccessIterator __last, _C
         _RandomAccessIterator __ptr = __first + __len;
         if (__comp(*__ptr, *--__last))
         {
-            value_type __t(_STD::move(*__last));
+            value_type __t(_VSTD::move(*__last));
             do
             {
-                *__last = _STD::move(*__ptr);
+                *__last = _VSTD::move(*__ptr);
                 __last = __ptr;
                 if (__len == 0)
                     break;
                 __len = (__len - 1) / 2;
                 __ptr = __first + __len;
             } while (__comp(*__ptr, __t));
-            *__last = _STD::move(__t);
+            *__last = _VSTD::move(__t);
         }
     }
 }
@@ -4468,7 +4468,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 push_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    _STD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::push_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // pop_heap
@@ -4506,7 +4506,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 pop_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    _STD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::pop_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // make_heap
@@ -4546,7 +4546,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 make_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    _STD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::make_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // sort_heap
@@ -4580,7 +4580,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 sort_heap(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
-    _STD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::sort_heap(__first, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // partial_sort
@@ -4624,7 +4624,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 partial_sort(_RandomAccessIterator __first, _RandomAccessIterator __middle, _RandomAccessIterator __last)
 {
-    _STD::partial_sort(__first, __middle, __last,
+    _VSTD::partial_sort(__first, __middle, __last,
                        __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
@@ -4675,7 +4675,7 @@ _RandomAccessIterator
 partial_sort_copy(_InputIterator __first, _InputIterator __last,
                   _RandomAccessIterator __result_first, _RandomAccessIterator __result_last)
 {
-    return _STD::partial_sort_copy(__first, __last, __result_first, __result_last,
+    return _VSTD::partial_sort_copy(__first, __last, __result_first, __result_last,
                                    __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
@@ -4704,7 +4704,7 @@ __nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _Rando
         case 3:
             {
             _RandomAccessIterator __m = __first;
-            _STD::__sort3<_Compare>(__first, ++__m, --__last, __comp);
+            _VSTD::__sort3<_Compare>(__first, ++__m, --__last, __comp);
             return;
             }
         }
@@ -4716,7 +4716,7 @@ __nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _Rando
         // __len > __limit >= 3
         _RandomAccessIterator __m = __first + __len/2;
         _RandomAccessIterator __lm1 = __last;
-        unsigned __n_swaps = _STD::__sort3<_Compare>(__first, __m, --__lm1, __comp);
+        unsigned __n_swaps = _VSTD::__sort3<_Compare>(__first, __m, --__lm1, __comp);
         // *__m is median
         // partition [__first, __m) < *__m and *__m <= [__m, __last)
         // (this inhibits tossing elements equivalent to __m around unnecessarily)
@@ -4886,7 +4886,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 nth_element(_RandomAccessIterator __first, _RandomAccessIterator __nth, _RandomAccessIterator __last)
 {
-    _STD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
+    _VSTD::nth_element(__first, __nth, __last, __less<typename iterator_traits<_RandomAccessIterator>::value_type>());
 }
 
 // includes
@@ -4927,7 +4927,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 includes(_InputIterator1 __first1, _InputIterator1 __last1, _InputIterator2 __first2, _InputIterator2 __last2)
 {
-    return _STD::includes(__first1, __last1, __first2, __last2,
+    return _VSTD::includes(__first1, __last1, __first2, __last2,
                           __less<typename iterator_traits<_InputIterator1>::value_type,
                                  typename iterator_traits<_InputIterator2>::value_type>());
 }
@@ -4942,7 +4942,7 @@ __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
     for (; __first1 != __last1; ++__result)
     {
         if (__first2 == __last2)
-            return _STD::copy(__first1, __last1, __result);
+            return _VSTD::copy(__first1, __last1, __result);
         if (__comp(*__first2, *__first1))
         {
             *__result = *__first2;
@@ -4956,7 +4956,7 @@ __set_union(_InputIterator1 __first1, _InputIterator1 __last1,
             ++__first1;
         }
     }
-    return _STD::copy(__first2, __last2, __result);
+    return _VSTD::copy(__first2, __last2, __result);
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
@@ -4981,7 +4981,7 @@ _OutputIterator
 set_union(_InputIterator1 __first1, _InputIterator1 __last1,
           _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
 {
-    return _STD::set_union(__first1, __last1, __first2, __last2, __result,
+    return _VSTD::set_union(__first1, __last1, __first2, __last2, __result,
                           __less<typename iterator_traits<_InputIterator1>::value_type,
                                  typename iterator_traits<_InputIterator2>::value_type>());
 }
@@ -5033,7 +5033,7 @@ _OutputIterator
 set_intersection(_InputIterator1 __first1, _InputIterator1 __last1,
                  _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
 {
-    return _STD::set_intersection(__first1, __last1, __first2, __last2, __result,
+    return _VSTD::set_intersection(__first1, __last1, __first2, __last2, __result,
                                   __less<typename iterator_traits<_InputIterator1>::value_type,
                                          typename iterator_traits<_InputIterator2>::value_type>());
 }
@@ -5048,7 +5048,7 @@ __set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     while (__first1 != __last1)
     {
         if (__first2 == __last2)
-            return _STD::copy(__first1, __last1, __result);
+            return _VSTD::copy(__first1, __last1, __result);
         if (__comp(*__first1, *__first2))
         {
             *__result = *__first1;
@@ -5087,7 +5087,7 @@ _OutputIterator
 set_difference(_InputIterator1 __first1, _InputIterator1 __last1,
                _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
 {
-    return _STD::set_difference(__first1, __last1, __first2, __last2, __result,
+    return _VSTD::set_difference(__first1, __last1, __first2, __last2, __result,
                                 __less<typename iterator_traits<_InputIterator1>::value_type,
                                        typename iterator_traits<_InputIterator2>::value_type>());
 }
@@ -5102,7 +5102,7 @@ __set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
     while (__first1 != __last1)
     {
         if (__first2 == __last2)
-            return _STD::copy(__first1, __last1, __result);
+            return _VSTD::copy(__first1, __last1, __result);
         if (__comp(*__first1, *__first2))
         {
             *__result = *__first1;
@@ -5121,7 +5121,7 @@ __set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
             ++__first2;
         }
     }
-    return _STD::copy(__first2, __last2, __result);
+    return _VSTD::copy(__first2, __last2, __result);
 }
 
 template <class _InputIterator1, class _InputIterator2, class _OutputIterator, class _Compare>
@@ -5146,7 +5146,7 @@ _OutputIterator
 set_symmetric_difference(_InputIterator1 __first1, _InputIterator1 __last1,
                          _InputIterator2 __first2, _InputIterator2 __last2, _OutputIterator __result)
 {
-    return _STD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
+    return _VSTD::set_symmetric_difference(__first1, __last1, __first2, __last2, __result,
                                           __less<typename iterator_traits<_InputIterator1>::value_type,
                                                  typename iterator_traits<_InputIterator2>::value_type>());
 }
@@ -5190,7 +5190,7 @@ bool
 lexicographical_compare(_InputIterator1 __first1, _InputIterator1 __last1,
                         _InputIterator2 __first2, _InputIterator2 __last2)
 {
-    return _STD::lexicographical_compare(__first1, __last1, __first2, __last2,
+    return _VSTD::lexicographical_compare(__first1, __last1, __first2, __last2,
                                          __less<typename iterator_traits<_InputIterator1>::value_type,
                                                 typename iterator_traits<_InputIterator2>::value_type>());
 }
@@ -5213,12 +5213,12 @@ __next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last
             while (!__comp(*__i, *--__j))
                 ;
             swap(*__i, *__j);
-            _STD::reverse(__ip1, __last);
+            _VSTD::reverse(__ip1, __last);
             return true;
         }
         if (__i == __first)
         {
-            _STD::reverse(__first, __last);
+            _VSTD::reverse(__first, __last);
             return false;
         }
     }
@@ -5244,7 +5244,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 next_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
 {
-    return _STD::next_permutation(__first, __last,
+    return _VSTD::next_permutation(__first, __last,
                                   __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
 }
 
@@ -5266,12 +5266,12 @@ __prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last
             while (!__comp(*--__j, *__i))
                 ;
             swap(*__i, *__j);
-            _STD::reverse(__ip1, __last);
+            _VSTD::reverse(__ip1, __last);
             return true;
         }
         if (__i == __first)
         {
-            _STD::reverse(__first, __last);
+            _VSTD::reverse(__first, __last);
             return false;
         }
     }
@@ -5297,7 +5297,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 prev_permutation(_BidirectionalIterator __first, _BidirectionalIterator __last)
 {
-    return _STD::prev_permutation(__first, __last,
+    return _VSTD::prev_permutation(__first, __last,
                                   __less<typename iterator_traits<_BidirectionalIterator>::value_type>());
 }