Tagging 25

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-25@135270 91177308-0d34-0410-b5e6-96231b3b80d8

Makefile

@@ -15,6 +15,9 @@ else
 	INSTALL_PREFIX="$(SDKROOT)"
 endif
 
+help::
+	echo Use make install DSTROOT=<destination>
+
 installsrc:: $(SRCROOT)
 
 	ditto $(SRCDIRS)/include $(SRCROOT)/include

include/__bit_reference

@@ -21,7 +21,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _C, bool _IsConst> class __bit_iterator;
 template <class _C> class __bit_const_reference;
 
-template <class _C>
+template <class _Tp>
+struct __has_storage_type
+{
+    static const bool value = false;
+};
+
+template <class _C, bool = __has_storage_type<_C>::value>
 class __bit_reference
 {
     typedef typename _C::__storage_type    __storage_type;
@@ -66,6 +72,11 @@ private:
         : __seg_(__s), __mask_(__m) {}
 };
 
+template <class _C>
+class __bit_reference<_C, false>
+{
+};
+
 template <class _C, class _D>
 _LIBCPP_INLINE_VISIBILITY inline
 void
@@ -142,25 +153,25 @@ __find_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _STD::min(__clz_f, __n);
+        __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         __storage_type __b = *__first.__seg_ & __m;
         if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
         __n -= __dn;
         ++__first.__seg_;
     }
     // do middle whole words
     for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
         if (*__first.__seg_)
-            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(*__first.__seg_)));
+            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(*__first.__seg_)));
     // do last partial word
     if (__n > 0)
     {
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         __storage_type __b = *__first.__seg_ & __m;
         if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
     }
     return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
@@ -176,11 +187,11 @@ __find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _STD::min(__clz_f, __n);
+        __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         __storage_type __b = ~(*__first.__seg_ & __m);
         if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
         __n -= __dn;
         ++__first.__seg_;
     }
@@ -189,7 +200,7 @@ __find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     {
         __storage_type __b = ~*__first.__seg_;
         if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
     }
     // do last partial word
     if (__n > 0)
@@ -197,7 +208,7 @@ __find_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
         __storage_type __b = ~(*__first.__seg_ & __m);
         if (__b)
-            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_VSTD::__ctz(__b)));
     }
     return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
@@ -227,20 +238,20 @@ __count_bool_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _STD::min(__clz_f, __n);
+        __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __r = _STD::__pop_count(*__first.__seg_ & __m);
+        __r = _VSTD::__pop_count(*__first.__seg_ & __m);
         __n -= __dn;
         ++__first.__seg_;
     }
     // do middle whole words
     for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
-        __r += _STD::__pop_count(*__first.__seg_);
+        __r += _VSTD::__pop_count(*__first.__seg_);
     // do last partial word
     if (__n > 0)
     {
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __r += _STD::__pop_count(*__first.__seg_ & __m);
+        __r += _VSTD::__pop_count(*__first.__seg_ & __m);
     }
     return __r;
 }
@@ -258,20 +269,20 @@ __count_bool_false(__bit_iterator<_C, false> __first, typename _C::size_type __n
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _STD::min(__clz_f, __n);
+        __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __r = _STD::__pop_count(~(*__first.__seg_ & __m));
+        __r = _VSTD::__pop_count(~(*__first.__seg_ & __m));
         __n -= __dn;
         ++__first.__seg_;
     }
     // do middle whole words
     for (; __n >= __bits_per_word; ++__first.__seg_, __n -= __bits_per_word)
-        __r += _STD::__pop_count(~*__first.__seg_);
+        __r += _VSTD::__pop_count(~*__first.__seg_);
     // do last partial word
     if (__n > 0)
     {
         __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __r += _STD::__pop_count(~(*__first.__seg_ & __m));
+        __r += _VSTD::__pop_count(~(*__first.__seg_ & __m));
     }
     return __r;
 }
@@ -299,7 +310,7 @@ __fill_n_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _STD::min(__clz_f, __n);
+        __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         *__first.__seg_ &= ~__m;
         __n -= __dn;
@@ -307,7 +318,7 @@ __fill_n_false(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     }
     // do middle whole words
     __storage_type __nw = __n / __bits_per_word;
-    _STD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
+    _VSTD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
     __n -= __nw * __bits_per_word;
     // do last partial word
     if (__n > 0)
@@ -329,7 +340,7 @@ __fill_n_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     if (__first.__ctz_ != 0)
     {
         __storage_type __clz_f = static_cast<__storage_type>(__bits_per_word - __first.__ctz_);
-        __storage_type __dn = _STD::min(__clz_f, __n);
+        __storage_type __dn = _VSTD::min(__clz_f, __n);
         __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
         *__first.__seg_ |= __m;
         __n -= __dn;
@@ -337,7 +348,7 @@ __fill_n_true(__bit_iterator<_C, false> __first, typename _C::size_type __n)
     }
     // do middle whole words
     __storage_type __nw = __n / __bits_per_word;
-    _STD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
+    _VSTD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
     __n -= __nw * __bits_per_word;
     // do last partial word
     if (__n > 0)
@@ -369,7 +380,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 fill(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, bool __value)
 {
-    _STD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
+    _VSTD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
 }
 
 // copy
@@ -390,7 +401,7 @@ __copy_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst
         if (__first.__ctz_ != 0)
         {
             unsigned __clz = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _STD::min(static_cast<difference_type>(__clz), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
             __storage_type __b = *__first.__seg_ & __m;
@@ -404,7 +415,7 @@ __copy_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst
         // __first.__ctz_ == 0;
         // do middle words
         __storage_type __nw = __n / __bits_per_word;
-        _STD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
+        _VSTD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
         __n -= __nw * __bits_per_word;
         __result.__seg_ += __nw;
         // do last word
@@ -437,12 +448,12 @@ __copy_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsCon
         if (__first.__ctz_ != 0)
         {
             unsigned __clz_f = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _STD::min(static_cast<difference_type>(__clz_f), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
             __storage_type __b = *__first.__seg_ & __m;
             unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __ddn = _STD::min<__storage_type>(__dn, __clz_r);
+            __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
             __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
             *__result.__seg_ &= ~__m;
             if (__result.__ctz_ > __first.__ctz_)
@@ -480,7 +491,7 @@ __copy_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsCon
         {
             __m = ~__storage_type(0) >> (__bits_per_word - __n);
             __storage_type __b = *__first.__seg_ & __m;
-            __storage_type __dn = _STD::min(__n, static_cast<difference_type>(__clz_r));
+            __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
             __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
             *__result.__seg_ &= ~__m;
             *__result.__seg_ |= __b << __result.__ctz_;
@@ -526,7 +537,7 @@ __copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C,
         // do first word
         if (__last.__ctz_ != 0)
         {
-            difference_type __dn = _STD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
             __n -= __dn;
             unsigned __clz = __bits_per_word - __last.__ctz_;
             __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz);
@@ -543,7 +554,7 @@ __copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C,
         __storage_type __nw = __n / __bits_per_word;
         __result.__seg_ -= __nw;
         __last.__seg_ -= __nw;
-        _STD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
+        _VSTD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
         __n -= __nw * __bits_per_word;
         // do last word
         if (__n > 0)
@@ -573,13 +584,13 @@ __copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_
         // do first word
         if (__last.__ctz_ != 0)
         {
-            difference_type __dn = _STD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
             __n -= __dn;
             unsigned __clz_l = __bits_per_word - __last.__ctz_;
             __storage_type __m = (~__storage_type(0) << (__last.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_l);
             __storage_type __b = *__last.__seg_ & __m;
             unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __ddn = _STD::min(__dn, static_cast<difference_type>(__result.__ctz_));
+            __storage_type __ddn = _VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
             if (__ddn > 0)
             {
                 __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
@@ -623,7 +634,7 @@ __copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_
             __m = ~__storage_type(0) << (__bits_per_word - __n);
             __storage_type __b = *--__last.__seg_ & __m;
             unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __dn = _STD::min(__n, static_cast<difference_type>(__result.__ctz_));
+            __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
             __m = (~__storage_type(0) << (__result.__ctz_ - __dn)) & (~__storage_type(0) >> __clz_r);
             *__result.__seg_ &= ~__m;
             *__result.__seg_ |= __b >> (__bits_per_word - __result.__ctz_);
@@ -661,7 +672,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 __bit_iterator<_C, false>
 move(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
 {
-    return _STD::copy(__first, __last, __result);
+    return _VSTD::copy(__first, __last, __result);
 }
 
 // move_backward
@@ -671,7 +682,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 __bit_iterator<_C, false>
 move_backward(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C, _IsConst> __last, __bit_iterator<_C, false> __result)
 {
-    return _STD::copy(__first, __last, __result);
+    return _VSTD::copy(__first, __last, __result);
 }
 
 // swap_ranges
@@ -692,7 +703,7 @@ __swap_ranges_aligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, fa
         if (__first.__ctz_ != 0)
         {
             unsigned __clz = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _STD::min(static_cast<difference_type>(__clz), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
             __storage_type __b1 = *__first.__seg_ & __m;
@@ -742,13 +753,13 @@ __swap_ranges_unaligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1,
         if (__first.__ctz_ != 0)
         {
             unsigned __clz_f = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _STD::min(static_cast<difference_type>(__clz_f), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
             __storage_type __b1 = *__first.__seg_ & __m;
             *__first.__seg_ &= ~__m;
             unsigned __clz_r = __bits_per_word - __result.__ctz_;
-            __storage_type __ddn = _STD::min<__storage_type>(__dn, __clz_r);
+            __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
             __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
             __storage_type __b2 = *__result.__seg_ & __m;
             *__result.__seg_ &= ~__m;
@@ -803,7 +814,7 @@ __swap_ranges_unaligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1,
             __m = ~__storage_type(0) >> (__bits_per_word - __n);
             __storage_type __b1 = *__first.__seg_ & __m;
             *__first.__seg_ &= ~__m;
-            __storage_type __dn = _STD::min<__storage_type>(__n, __clz_r);
+            __storage_type __dn = _VSTD::min<__storage_type>(__n, __clz_r);
             __m = (~__storage_type(0) << __result.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
             __storage_type __b2 = *__result.__seg_ & __m;
             *__result.__seg_ &= ~__m;
@@ -877,13 +888,13 @@ rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __
             if (__d1 <= __bit_array<_C>::capacity())
             {
                 __bit_array<_C> __b(__d1);
-                _STD::copy(__first, __middle, __b.begin());
-                _STD::copy(__b.begin(), __b.end(), _STD::copy(__middle, __last, __first));
+                _VSTD::copy(__first, __middle, __b.begin());
+                _VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
                 break;
             }
             else
             {
-                __bit_iterator<_C, false> __mp = _STD::swap_ranges(__first, __middle, __middle);
+                __bit_iterator<_C, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
                 __first = __middle;
                 __middle = __mp;
                 __d2 -= __d1;
@@ -894,14 +905,14 @@ rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __
             if (__d2 <= __bit_array<_C>::capacity())
             {
                 __bit_array<_C> __b(__d2);
-                _STD::copy(__middle, __last, __b.begin());
-                _STD::copy_backward(__b.begin(), __b.end(), _STD::copy_backward(__first, __middle, __last));
+                _VSTD::copy(__middle, __last, __b.begin());
+                _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
                 break;
             }
             else
             {
                 __bit_iterator<_C, false> __mp = __first + __d2;
-                _STD::swap_ranges(__first, __mp, __middle);
+                _VSTD::swap_ranges(__first, __mp, __middle);
                 __first = __mp;
                 __d1 -= __d2;
             }
@@ -928,12 +939,12 @@ __equal_unaligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __
         if (__first1.__ctz_ != 0)
         {
             unsigned __clz_f = __bits_per_word - __first1.__ctz_;
-            difference_type __dn = _STD::min(static_cast<difference_type>(__clz_f), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
             __storage_type __b = *__first1.__seg_ & __m;
             unsigned __clz_r = __bits_per_word - __first2.__ctz_;
-            __storage_type __ddn = _STD::min<__storage_type>(__dn, __clz_r);
+            __storage_type __ddn = _VSTD::min<__storage_type>(__dn, __clz_r);
             __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __ddn));
             if (__first2.__ctz_ > __first1.__ctz_)
                 if ((*__first2.__seg_ & __m) != (__b << (__first2.__ctz_ - __first1.__ctz_)))
@@ -972,7 +983,7 @@ __equal_unaligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __
         {
             __m = ~__storage_type(0) >> (__bits_per_word - __n);
             __storage_type __b = *__first1.__seg_ & __m;
-            __storage_type __dn = _STD::min(__n, static_cast<difference_type>(__clz_r));
+            __storage_type __dn = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
             __m = (~__storage_type(0) << __first2.__ctz_) & (~__storage_type(0) >> (__clz_r - __dn));
             if ((*__first2.__seg_ & __m) != (__b << __first2.__ctz_))
                 return false;
@@ -1006,7 +1017,7 @@ __equal_aligned(__bit_iterator<_C, true> __first1, __bit_iterator<_C, true> __la
         if (__first1.__ctz_ != 0)
         {
             unsigned __clz = __bits_per_word - __first1.__ctz_;
-            difference_type __dn = _STD::min(static_cast<difference_type>(__clz), __n);
+            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
             __n -= __dn;
             __storage_type __m = (~__storage_type(0) << __first1.__ctz_) & (~__storage_type(0) >> (__clz - __dn));
             if ((*__first2.__seg_ & __m) != (*__first1.__seg_ & __m))

include/__config

@@ -157,10 +157,19 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_TRAILING_RETURN
 #endif
 
+// Objective-C++ features (opt-in)
+#if __has_feature(objc_arc)
+#define _LIBCPP_HAS_OBJC_ARC
+#endif
+
+#if __has_feature(objc_arc_weak)
+#define _LIBCPP_HAS_OBJC_ARC_WEAK
+#endif
+
 // Inline namespaces are available in Clang regardless of C++ dialect.
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
-#define _STD std::_LIBCPP_NAMESPACE
+#define _VSTD std::_LIBCPP_NAMESPACE
 
 namespace std {
   inline namespace _LIBCPP_NAMESPACE {
@@ -238,7 +247,7 @@ namespace std {
 
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
-#define _STD std::_LIBCPP_NAMESPACE
+#define _VSTD std::_LIBCPP_NAMESPACE
 
 namespace std {
 namespace _LIBCPP_NAMESPACE {
@@ -276,4 +285,12 @@ template <unsigned> struct __static_assert_check {};
 #define __has_feature(__x) 0
 #endif
 
+#ifdef __APPLE__
+#define _LIBCPP_STABLE_APPLE_ABI
+#endif
+
+#ifdef __APPLE__
+#define _LIBCPP_WCTYPE_IS_MASK
+#endif
+
 #endif  // _LIBCPP_CONFIG

include/__functional_03

@@ -314,8 +314,8 @@ class __func<_F, _Alloc, _R()>
 {
     __compressed_pair<_F, _Alloc> __f_;
 public:
-    explicit __func(_F __f) : __f_(_STD::move(__f)) {}
-    explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::move(__a)) {}
+    explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
+    explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
     virtual __base<_R()>* __clone() const;
     virtual void __clone(__base<_R()>*) const;
     virtual void destroy();
@@ -396,9 +396,9 @@ class __func<_F, _Alloc, _R(_A0)>
 {
     __compressed_pair<_F, _Alloc> __f_;
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
+    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
-        : __f_(_STD::move(__f), _STD::move(__a)) {}
+        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
     virtual __base<_R(_A0)>* __clone() const;
     virtual void __clone(__base<_R(_A0)>*) const;
     virtual void destroy();
@@ -479,9 +479,9 @@ class __func<_F, _Alloc, _R(_A0, _A1)>
 {
     __compressed_pair<_F, _Alloc> __f_;
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
+    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
-        : __f_(_STD::move(__f), _STD::move(__a)) {}
+        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
     virtual __base<_R(_A0, _A1)>* __clone() const;
     virtual void __clone(__base<_R(_A0, _A1)>*) const;
     virtual void destroy();
@@ -562,9 +562,9 @@ class __func<_F, _Alloc, _R(_A0, _A1, _A2)>
 {
     __compressed_pair<_F, _Alloc> __f_;
 public:
-    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
+    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
-        : __f_(_STD::move(__f), _STD::move(__a)) {}
+        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
     virtual __base<_R(_A0, _A1, _A2)>* __clone() const;
     virtual void __clone(__base<_R(_A0, _A1, _A2)>*) const;
     virtual void destroy();
@@ -831,7 +831,7 @@ typename enable_if
 >::type
 function<_R()>::operator=(_F __f)
 {
-    function(_STD::move(__f)).swap(*this);
+    function(_VSTD::move(__f)).swap(*this);
     return *this;
 }
 
@@ -878,7 +878,7 @@ function<_R()>::swap(function& __f)
         __f_ = (__base*)&__buf_;
     }
     else
-        _STD::swap(__f_, __f.__f_);
+        _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _R>
@@ -1133,7 +1133,7 @@ typename enable_if
 >::type
 function<_R(_A0)>::operator=(_F __f)
 {
-    function(_STD::move(__f)).swap(*this);
+    function(_VSTD::move(__f)).swap(*this);
     return *this;
 }
 
@@ -1180,7 +1180,7 @@ function<_R(_A0)>::swap(function& __f)
         __f_ = (__base*)&__buf_;
     }
     else
-        _STD::swap(__f_, __f.__f_);
+        _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _R, class _A0>
@@ -1435,7 +1435,7 @@ typename enable_if
 >::type
 function<_R(_A0, _A1)>::operator=(_F __f)
 {
-    function(_STD::move(__f)).swap(*this);
+    function(_VSTD::move(__f)).swap(*this);
     return *this;
 }
 
@@ -1482,7 +1482,7 @@ function<_R(_A0, _A1)>::swap(function& __f)
         __f_ = (__base*)&__buf_;
     }
     else
-        _STD::swap(__f_, __f.__f_);
+        _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _R, class _A0, class _A1>
@@ -1737,7 +1737,7 @@ typename enable_if
 >::type
 function<_R(_A0, _A1, _A2)>::operator=(_F __f)
 {
-    function(_STD::move(__f)).swap(*this);
+    function(_VSTD::move(__f)).swap(*this);
     return *this;
 }
 
@@ -1784,7 +1784,7 @@ function<_R(_A0, _A1, _A2)>::swap(function& __f)
         __f_ = (__base*)&__buf_;
     }
     else
-        _STD::swap(__f_, __f.__f_);
+        _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _R, class _A0, class _A1, class _A2>
@@ -1909,7 +1909,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename __mu_return1<true, _Ti, _Uj...>::type
 __mu_expand(_Ti& __ti, tuple<_Uj...>&& __uj, __tuple_indices<_Indx...>)
 {
-    __ti(_STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj))...);
+    __ti(_VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj))...);
 }
 
 template <class _Ti, class ..._Uj>
@@ -1947,7 +1947,7 @@ __mu(_Ti&, _Uj& __uj)
     // compiler bug workaround
     typename tuple_element<_Indx, _Uj>::type __t = get<_Indx>(__uj);
     return __t;
-//    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+//    return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
 }
 
 template <class _Ti, class _Uj>
@@ -2051,8 +2051,8 @@ class __bind
 public:
     template <class _G, class ..._BA>
       explicit __bind(_G&& __f, _BA&& ...__bound_args)
-        : __f_(_STD::forward<_G>(__f)),
-          __bound_args_(_STD::forward<_BA>(__bound_args)...) {}
+        : __f_(_VSTD::forward<_G>(__f)),
+          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         typename __bind_return<_F, tuple<_BoundArgs...>, tuple<_Args&&...> >::type
@@ -2085,21 +2085,21 @@ public:
 
     template <class _G, class ..._BA>
       explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
-        : base(_STD::forward<_G>(__f),
-               _STD::forward<_BA>(__bound_args)...) {}
+        : base(_VSTD::forward<_G>(__f),
+               _VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         result_type
         operator()(_Args&& ...__args)
         {
-            return base::operator()(_STD::forward<_Args>(__args)...);
+            return base::operator()(_VSTD::forward<_Args>(__args)...);
         }
 
     template <class ..._Args>
         result_type
         operator()(_Args&& ...__args) const
         {
-            return base::operator()(_STD::forward<_Args>(__args)...);
+            return base::operator()(_VSTD::forward<_Args>(__args)...);
         }
 };
 
@@ -2112,7 +2112,7 @@ __bind<typename decay<_F>::type, typename decay<_BoundArgs>::type...>
 bind(_F&& __f, _BoundArgs&&... __bound_args)
 {
     typedef __bind<typename decay<_F>::type, typename decay<_BoundArgs>::type...> type;
-    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
+    return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 }
 
 template<class _R, class _F, class ..._BoundArgs>
@@ -2121,7 +2121,7 @@ __bind_r<_R, typename decay<_F>::type, typename decay<_BoundArgs>::type...>
 bind(_F&& __f, _BoundArgs&&... __bound_args)
 {
     typedef __bind_r<_R, typename decay<_F>::type, typename decay<_BoundArgs>::type...> type;
-    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
+    return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 }
 */
 

include/__functional_base

@@ -287,18 +287,18 @@ template <class _F, class _A0, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...))
+    -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
 {
-    return (_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...);
+    return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...);
 }
 
 template <class _F, class _A0, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...))
+    -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
 {
-    return ((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...);
+    return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...);
 }
 
 // bullets 3 and 4
@@ -307,18 +307,18 @@ template <class _F, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype(_STD::forward<_A0>(__a0).*__f)
+    -> decltype(_VSTD::forward<_A0>(__a0).*__f)
 {
-    return _STD::forward<_A0>(__a0).*__f;
+    return _VSTD::forward<_A0>(__a0).*__f;
 }
 
 template <class _F, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype((*_STD::forward<_A0>(__a0)).*__f)
+    -> decltype((*_VSTD::forward<_A0>(__a0)).*__f)
 {
-    return (*_STD::forward<_A0>(__a0)).*__f;
+    return (*_VSTD::forward<_A0>(__a0)).*__f;
 }
 
 // bullet 5
@@ -327,15 +327,15 @@ template <class _F, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _Args&& ...__args)
-    -> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...))
+    -> decltype(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...))
 {
-    return _STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...);
+    return _VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...);
 }
 
 template <class _Tp, class ..._Args>
 struct __invoke_return
 {
-    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_Args>()...)) type;
+    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
 };
 
 template <class _Tp>
@@ -365,7 +365,7 @@ public:
        typename __invoke_of<type&, _ArgTypes...>::type
           operator() (_ArgTypes&&... __args) const
           {
-              return __invoke(get(), _STD::forward<_ArgTypes>(__args)...);
+              return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
           }
 };
 

include/__functional_base_03

@@ -842,7 +842,7 @@ struct __4th_helper
 template <class _T1, class _R>
 struct __4th_helper<_T1, _R, true>
 {
-    typedef typename __apply_cv<decltype(*_STD::declval<_T1>()), _R>::type type;
+    typedef typename __apply_cv<decltype(*_VSTD::declval<_T1>()), _R>::type type;
 };
 
 template <class _R, class _T, class _T1>
@@ -959,13 +959,13 @@ struct __invoke_return
 template <class _F>
 struct __invoke_return<_F, false>
 {
-    typedef decltype(__invoke(_STD::declval<_F>())) type;
+    typedef decltype(__invoke(_VSTD::declval<_F>())) type;
 };
 
 template <class _Tp, class _A0>
 struct __invoke_return0
 {
-    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>())) type;
+    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>())) type;
 };
 
 template <class _R, class _T, class _A0>
@@ -983,16 +983,16 @@ struct __invoke_return0<_R _T::*, _A0*>
 template <class _Tp, class _A0, class _A1>
 struct __invoke_return1
 {
-    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>(),
-                                                    _STD::declval<_A1>())) type;
+    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
+                                                    _VSTD::declval<_A1>())) type;
 };
 
 template <class _Tp, class _A0, class _A1, class _A2>
 struct __invoke_return2
 {
-    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>(),
-                                                    _STD::declval<_A1>(),
-                                                    _STD::declval<_A2>())) type;
+    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
+                                                    _VSTD::declval<_A1>(),
+                                                    _VSTD::declval<_A2>())) type;
 };
 
 template <class _Tp>

include/__hash_table

@@ -23,7 +23,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD
 
 _LIBCPP_VISIBLE
-size_t __next_prime(size_t);
+size_t __next_prime(size_t __n);
 
 template <class _NodePtr>
 struct __hash_node_base
@@ -54,11 +54,12 @@ struct __hash_node
     value_type __value_;
 };
 
-template <class, class, class, class> class __hash_table;
-template <class> class __hash_const_iterator;
-template <class> class __hash_map_iterator;
-template <class> class __hash_map_const_iterator;
-template <class, class, class, class, class> class _LIBCPP_VISIBLE unordered_map;
+template <class _Tp, class _Hash, class _Equal, class _Alloc> class __hash_table;
+template <class _ConstNodePtr> class __hash_const_iterator;
+template <class _HashIterator> class __hash_map_iterator;
+template <class _HashIterator> class __hash_map_const_iterator;
+template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
+    class _LIBCPP_VISIBLE unordered_map;
 
 template <class _NodePtr>
 class _LIBCPP_VISIBLE __hash_iterator
@@ -85,7 +86,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
         reference operator*() const {return __node_->__value_;}
     _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return _STD::addressof(__node_->__value_);}
+        pointer operator->() const {return _VSTD::addressof(__node_->__value_);}
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_iterator& operator++()
@@ -163,7 +164,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
         reference operator*() const {return __node_->__value_;}
     _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return _STD::addressof(__node_->__value_);}
+        pointer operator->() const {return _VSTD::addressof(__node_->__value_);}
 
     _LIBCPP_INLINE_VISIBILITY
     __hash_const_iterator& operator++()
@@ -199,7 +200,7 @@ private:
     template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
 };
 
-template <class> class _LIBCPP_VISIBLE __hash_const_local_iterator;
+template <class _ConstNodePtr> class _LIBCPP_VISIBLE __hash_const_local_iterator;
 
 template <class _NodePtr>
 class _LIBCPP_VISIBLE __hash_local_iterator
@@ -387,7 +388,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     __bucket_list_deallocator(__bucket_list_deallocator&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-        : __data_(_STD::move(__x.__data_))
+        : __data_(_VSTD::move(__x.__data_))
     {
         __x.size() = 0;
     }
@@ -411,7 +412,7 @@ public:
     }
 };
 
-template <class> class __hash_map_node_destructor;
+template <class _Alloc> class __hash_map_node_destructor;
 
 template <class _Alloc>
 class __hash_node_destructor
@@ -440,7 +441,7 @@ public:
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__value_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
@@ -687,7 +688,7 @@ public:
         return __bc != 0 ? (float)size() / __bc : 0.f;
     }
     _LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) _NOEXCEPT
-        {max_load_factor() = _STD::max(__mlf, load_factor());}
+        {max_load_factor() = _VSTD::max(__mlf, load_factor());}
 
     _LIBCPP_INLINE_VISIBILITY local_iterator       begin(size_type __n)
         {return local_iterator(__bucket_list_[__n], __n, bucket_count());}
@@ -740,8 +741,8 @@ private:
             is_nothrow_move_assignable<__node_allocator>::value)
     {
         __bucket_list_.get_deleter().__alloc() =
-                _STD::move(__u.__bucket_list_.get_deleter().__alloc());
-        __node_alloc() = _STD::move(__u.__node_alloc());
+                _VSTD::move(__u.__bucket_list_.get_deleter().__alloc());
+        __node_alloc() = _VSTD::move(__u.__node_alloc());
     }
     _LIBCPP_INLINE_VISIBILITY
         void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
@@ -768,7 +769,7 @@ private:
     __swap_alloc(_A& __x, _A& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<_A>::value)
     {
-        using _STD::swap;
+        using _VSTD::swap;
         swap(__x, __y);
     }
 
@@ -858,15 +859,15 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
             is_nothrow_move_constructible<__first_node>::value &&
             is_nothrow_move_constructible<hasher>::value &&
             is_nothrow_move_constructible<key_equal>::value)
-    : __bucket_list_(_STD::move(__u.__bucket_list_)),
-      __p1_(_STD::move(__u.__p1_)),
-      __p2_(_STD::move(__u.__p2_)),
-      __p3_(_STD::move(__u.__p3_))
+    : __bucket_list_(_VSTD::move(__u.__bucket_list_)),
+      __p1_(_VSTD::move(__u.__p1_)),
+      __p2_(_VSTD::move(__u.__p2_)),
+      __p3_(_VSTD::move(__u.__p3_))
 {
     if (size() > 0)
     {
         __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
         __u.__p1_.first().__next_ = nullptr;
         __u.size() = 0;
     }
@@ -877,8 +878,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
                                                        const allocator_type& __a)
     : __bucket_list_(nullptr, __bucket_list_deleter(__pointer_allocator(__a), 0)),
       __p1_(__node_allocator(__a)),
-      __p2_(0, _STD::move(__u.hash_function())),
-      __p3_(_STD::move(__u.__p3_))
+      __p2_(0, _VSTD::move(__u.hash_function())),
+      __p3_(_VSTD::move(__u.__p3_))
 {
     if (__a == allocator_type(__u.__node_alloc()))
     {
@@ -890,7 +891,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u,
             __p1_.first().__next_ = __u.__p1_.first().__next_;
             __u.__p1_.first().__next_ = nullptr;
             __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-                static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+                static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
             size() = __u.size();
             __u.size() = 0;
         }
@@ -944,7 +945,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)
     while (__np != nullptr)
     {
         __node_pointer __next = __np->__next_;
-        __node_traits::destroy(__na, _STD::addressof(__np->__value_));
+        __node_traits::destroy(__na, _VSTD::addressof(__np->__value_));
         __node_traits::deallocate(__na, __np, 1);
         __np = __next;
     }
@@ -980,14 +981,14 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
     __u.__bucket_list_.get_deleter().size() = 0;
     __move_assign_alloc(__u);
     size() = __u.size();
-    hash_function() = _STD::move(__u.hash_function());
+    hash_function() = _VSTD::move(__u.hash_function());
     max_load_factor() = __u.max_load_factor();
-    key_eq() = _STD::move(__u.key_eq());
+    key_eq() = _VSTD::move(__u.key_eq());
     __p1_.first().__next_ = __u.__p1_.first().__next_;
     if (size() > 0)
     {
         __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
         __u.__p1_.first().__next_ = nullptr;
         __u.size() = 0;
     }
@@ -1002,8 +1003,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
         __move_assign(__u, true_type());
     else
     {
-        hash_function() = _STD::move(__u.hash_function());
-        key_eq() = _STD::move(__u.key_eq());
+        hash_function() = _VSTD::move(__u.hash_function());
+        key_eq() = _VSTD::move(__u.key_eq());
         max_load_factor() = __u.max_load_factor();
         if (bucket_count() != 0)
         {
@@ -1015,7 +1016,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
                 const_iterator __i = __u.begin();
                 while (__cache != nullptr && __u.size() != 0)
                 {
-                    __cache->__value_ = _STD::move(__u.remove(__i++)->__value_);
+                    __cache->__value_ = _VSTD::move(__u.remove(__i++)->__value_);
                     __node_pointer __next = __cache->__next_;
                     __node_insert_multi(__cache);
                     __cache = __next;
@@ -1034,7 +1035,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
         while (__u.size() != 0)
         {
             __node_holder __h =
-                    __construct_node(_STD::move(__u.remove(__i++)->__value_));
+                    __construct_node(_VSTD::move(__u.remove(__i++)->__value_));
             __node_insert_multi(__h.get());
             __h.release();
         }
@@ -1167,7 +1168,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
         __deallocate(__p1_.first().__next_);
         __p1_.first().__next_ = nullptr;
         size_type __bc = bucket_count();
-        for (size_type __i; __i < __bc; ++__i)
+        for (size_type __i = 0; __i < __bc; ++__i)
             __bucket_list_[__i] = nullptr;
         size() = 0;
     }
@@ -1200,7 +1201,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
     {
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
-            rehash(_STD::max<size_type>(2 * __bc + 1,
+            rehash(_VSTD::max<size_type>(2 * __bc + 1,
                            size_type(ceil(float(size() + 1) / max_load_factor()))));
             __bc = bucket_count();
             __chash = __nd->__hash_ % __bc;
@@ -1209,7 +1210,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
         __node_pointer __pn = __bucket_list_[__chash];
         if (__pn == nullptr)
         {
-            __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
             __nd->__next_ = __pn->__next_;
             __pn->__next_ = __nd;
             // fix up __bucket_list_
@@ -1239,7 +1240,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
     size_type __bc = bucket_count();
     if (size()+1 > __bc * max_load_factor() || __bc == 0)
     {
-        rehash(_STD::max<size_type>(2 * __bc + 1,
+        rehash(_VSTD::max<size_type>(2 * __bc + 1,
                        size_type(ceil(float(size() + 1) / max_load_factor()))));
         __bc = bucket_count();
     }
@@ -1247,7 +1248,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(__node_pointer __c
     __node_pointer __pn = __bucket_list_[__chash];
     if (__pn == nullptr)
     {
-        __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+        __pn = static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
         __cp->__next_ = __pn->__next_;
         __pn->__next_ = __cp;
         // fix up __bucket_list_
@@ -1300,7 +1301,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_multi(
         size_type __bc = bucket_count();
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
-            rehash(_STD::max<size_type>(2 * __bc + 1,
+            rehash(_VSTD::max<size_type>(2 * __bc + 1,
                            size_type(ceil(float(size() + 1) / max_load_factor()))));
             __bc = bucket_count();
         }
@@ -1344,7 +1345,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
         __node_holder __h = __construct_node(__x, __hash);
         if (size()+1 > __bc * max_load_factor() || __bc == 0)
         {
-            rehash(_STD::max<size_type>(2 * __bc + 1,
+            rehash(_VSTD::max<size_type>(2 * __bc + 1,
                            size_type(ceil(float(size() + 1) / max_load_factor()))));
             __bc = bucket_count();
             __chash = __hash % __bc;
@@ -1353,7 +1354,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(const value_type& __x)
         __node_pointer __pn = __bucket_list_[__chash];
         if (__pn == nullptr)
         {
-            __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
             __h->__next_ = __pn->__next_;
             __pn->__next_ = __h.get();
             // fix up __bucket_list_
@@ -1383,7 +1384,7 @@ template <class... _Args>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_unique(_Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     pair<iterator, bool> __r = __node_insert_unique(__h.get());
     if (__r.second)
         __h.release();
@@ -1395,7 +1396,7 @@ template <class... _Args>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_multi(_Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     iterator __r = __node_insert_multi(__h.get());
     __h.release();
     return __r;
@@ -1407,7 +1408,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__emplace_hint_multi(
         const_iterator __p, _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     iterator __r = __node_insert_multi(__p, __h.get());
     __h.release();
     return __r;
@@ -1420,7 +1421,7 @@ template <class _P>
 pair<typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator, bool>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_unique(_P&& __x)
 {
-    __node_holder __h = __construct_node(_STD::forward<_P>(__x));
+    __node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
     pair<iterator, bool> __r = __node_insert_unique(__h.get());
     if (__r.second)
         __h.release();
@@ -1436,7 +1437,7 @@ template <class _P>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(_P&& __x)
 {
-    __node_holder __h = __construct_node(_STD::forward<_P>(__x));
+    __node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
     iterator __r = __node_insert_multi(__h.get());
     __h.release();
     return __r;
@@ -1448,7 +1449,7 @@ typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__insert_multi(const_iterator __p,
                                                          _P&& __x)
 {
-    __node_holder __h = __construct_node(_STD::forward<_P>(__x));
+    __node_holder __h = __construct_node(_VSTD::forward<_P>(__x));
     iterator __r = __node_insert_multi(__p, __h.get());
     __h.release();
     return __r;
@@ -1483,13 +1484,13 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)
 {
-    __n = __next_prime(_STD::max<size_type>(__n, size() > 0));
+    __n = __next_prime(_VSTD::max<size_type>(__n, size() > 0));
     size_type __bc = bucket_count();
     if (__n > __bc)
         __rehash(__n);
     else
     {
-        __n = _STD::max<size_type>
+        __n = _VSTD::max<size_type>
               (
                   __n,
                   __next_prime(size_t(ceil(float(size()) / max_load_factor())))
@@ -1511,7 +1512,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__rehash(size_type __nbc)
     {
         for (size_type __i = 0; __i < __nbc; ++__i)
             __bucket_list_[__i] = nullptr;
-        __node_pointer __pp(static_cast<__node_pointer>(_STD::addressof(__p1_.first())));
+        __node_pointer __pp(static_cast<__node_pointer>(_VSTD::addressof(__p1_.first())));
         __node_pointer __cp = __pp->__next_;
         if (__cp != nullptr)
         {
@@ -1611,7 +1612,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(_Args&& ...__args)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = hash_function()(__h->__value_);
     __h->__next_ = nullptr;
@@ -1627,11 +1628,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = __hash;
     __h->__next_ = nullptr;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1642,11 +1643,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = hash_function()(__h->__value_);
     __h->__next_ = nullptr;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1658,11 +1659,11 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
     __h->__hash_ = __hash;
     __h->__next_ = nullptr;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1736,7 +1737,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
     // Fix up __bucket_list_
         // if __pn is not in same bucket (before begin is not in same bucket) &&
         //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
-    if (__pn == _STD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
+    if (__pn == _VSTD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
     {
         if (__cn->__next_ == nullptr || __cn->__next_->__hash_ % __bc != __chash)
             __bucket_list_[__chash] = nullptr;
@@ -1867,19 +1868,19 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
     __bucket_list_.reset(__u.__bucket_list_.release());
     __u.__bucket_list_.reset(__npp);
     }
-    _STD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
+    _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
     __swap_alloc(__bucket_list_.get_deleter().__alloc(),
              __u.__bucket_list_.get_deleter().__alloc());
     __swap_alloc(__node_alloc(), __u.__node_alloc());
-    _STD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
+    _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
     __p2_.swap(__u.__p2_);
     __p3_.swap(__u.__p3_);
     if (size() > 0)
         __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
     if (__u.size() > 0)
         __u.__bucket_list_[__u.__p1_.first().__next_->__hash_ % __u.bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__u.__p1_.first()));
+            static_cast<__node_pointer>(_VSTD::addressof(__u.__p1_.first()));
 }
 
 template <class _Tp, class _Hash, class _Equal, class _Alloc>

include/__locale

@@ -137,10 +137,10 @@ locale
 locale::combine(const locale& __other) const
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    if (!_STD::has_facet<_Facet>(__other))
+    if (!_VSTD::has_facet<_Facet>(__other))
         throw runtime_error("locale::combine: locale missing facet");
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    return locale(*this, &const_cast<_Facet&>(_STD::use_facet<_Facet>(__other)));
+    return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
 }
 
 template <class _Facet>
@@ -292,7 +292,7 @@ bool
 locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
                    const basic_string<_CharT, _Traits, _Allocator>& __y) const
 {
-    return _STD::use_facet<_STD::collate<_CharT> >(*this).compare(
+    return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
                                        __x.data(), __x.data() + __x.size(),
                                        __y.data(), __y.data() + __y.size()) < 0;
 }
@@ -302,7 +302,11 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
 class _LIBCPP_VISIBLE ctype_base
 {
 public:
+#ifdef __GLIBC__
+    typedef unsigned short mask;
+#else
     typedef __uint32_t mask;
+#endif
 
 #if __APPLE__
     static const mask space  = _CTYPE_S;
@@ -537,6 +541,10 @@ public:
 #endif
     _LIBCPP_ALWAYS_INLINE const mask* table() const  _NOEXCEPT {return __tab_;}
     static const mask* classic_table()  _NOEXCEPT;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+    static const int* __classic_upper_table() _NOEXCEPT;
+    static const int* __classic_lower_table() _NOEXCEPT;
+#endif
 
 protected:
     ~ctype();

include/__mutex_base

@@ -21,8 +21,8 @@
 #ifdef _LIBCPP_SHARED_LOCK
 
 namespace ting {
-template <class> class shared_lock;
-template <class> class upgrade_lock;
+template <class _Mutex> class shared_lock;
+template <class _Mutex> class upgrade_lock;
 }
 
 #endif  // _LIBCPP_SHARED_LOCK
@@ -190,8 +190,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     void swap(unique_lock& __u)
     {
-        _STD::swap(__m_, __u.__m_);
-        _STD::swap(__owns_, __u.__owns_);
+        _VSTD::swap(__m_, __u.__m_);
+        _VSTD::swap(__owns_, __u.__owns_);
     }
     _LIBCPP_INLINE_VISIBILITY
     mutex_type* release()
@@ -429,7 +429,7 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
                              _Predicate __pred)
 {
     return wait_until(__lk, chrono::steady_clock::now() + __d,
-                      _STD::move(__pred));
+                      _VSTD::move(__pred));
 }
 
 _LIBCPP_END_NAMESPACE_STD

include/__split_buffer

@@ -144,7 +144,7 @@ private:
     void __move_assign_alloc(const __split_buffer& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
-            __alloc() = _STD::move(__c.__alloc());
+            __alloc() = _VSTD::move(__c.__alloc());
         }
 
     _LIBCPP_INLINE_VISIBILITY
@@ -162,7 +162,7 @@ private:
     static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<__alloc_rr>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
 
@@ -208,7 +208,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
     __alloc_rr& __a = this->__alloc();
     do
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), value_type());
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), value_type());
         ++this->__end_;
         --__n;
     } while (__n > 0);
@@ -227,7 +227,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_referen
     __alloc_rr& __a = this->__alloc();
     do
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), __x);
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
         ++this->__end_;
         --__n;
     } while (__n > 0);
@@ -249,14 +249,14 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_InputIter __first, _InputIt
         if (__end_ == __end_cap())
         {
             size_type __old_cap = __end_cap() - __first_;
-            size_type __new_cap = _STD::max<size_type>(2 * __old_cap, 8);
+            size_type __new_cap = _VSTD::max<size_type>(2 * __old_cap, 8);
             __split_buffer __buf(__new_cap, 0, __a);
             for (pointer __p = __begin_; __p != __end_; ++__p, ++__buf.__end_)
                 __alloc_traits::construct(__buf.__alloc(),
-                        _STD::__to_raw_pointer(__buf.__end_), _STD::move(*__p));
+                        _VSTD::__to_raw_pointer(__buf.__end_), _VSTD::move(*__p));
             swap(__buf);
         }
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
         ++this->__end_;
     }
 }
@@ -273,7 +273,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _F
     __alloc_rr& __a = this->__alloc();
     for (; __first != __last; ++__first)
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
         ++this->__end_;
     }
 }
@@ -356,10 +356,10 @@ __split_buffer<_Tp, _Allocator>::~__split_buffer()
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-    : __first_(_STD::move(__c.__first_)),
-      __begin_(_STD::move(__c.__begin_)),
-      __end_(_STD::move(__c.__end_)),
-      __end_cap_(_STD::move(__c.__end_cap_))
+    : __first_(_VSTD::move(__c.__first_)),
+      __begin_(_VSTD::move(__c.__begin_)),
+      __end_(_VSTD::move(__c.__end_)),
+      __end_cap_(_VSTD::move(__c.__end_cap_))
 {
     __c.__first_ = nullptr;
     __c.__begin_ = nullptr;
@@ -421,10 +421,10 @@ __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
                    __is_nothrow_swappable<__alloc_rr>::value)
 {
-    _STD::swap(__first_, __x.__first_);
-    _STD::swap(__begin_, __x.__begin_);
-    _STD::swap(__end_, __x.__end_);
-    _STD::swap(__end_cap(), __x.__end_cap());
+    _VSTD::swap(__first_, __x.__first_);
+    _VSTD::swap(__begin_, __x.__begin_);
+    _VSTD::swap(__end_, __x.__end_);
+    _VSTD::swap(__end_cap(), __x.__end_cap());
     __swap_alloc(__alloc(), __x.__alloc());
 }
 
@@ -437,10 +437,10 @@ __split_buffer<_Tp, _Allocator>::reserve(size_type __n)
         __split_buffer<value_type, __alloc_rr&> __t(__n, 0, __alloc());
         __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                move_iterator<pointer>(__end_));
-        _STD::swap(__first_, __t.__first_);
-        _STD::swap(__begin_, __t.__begin_);
-        _STD::swap(__end_, __t.__end_);
-        _STD::swap(__end_cap(), __t.__end_cap());
+        _VSTD::swap(__first_, __t.__first_);
+        _VSTD::swap(__begin_, __t.__begin_);
+        _VSTD::swap(__end_, __t.__end_);
+        _VSTD::swap(__end_cap(), __t.__end_cap());
     }
 }
 
@@ -458,10 +458,10 @@ __split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
             __t.__end_ = __t.__begin_ + (__end_ - __begin_);
-            _STD::swap(__first_, __t.__first_);
-            _STD::swap(__begin_, __t.__begin_);
-            _STD::swap(__end_, __t.__end_);
-            _STD::swap(__end_cap(), __t.__end_cap());
+            _VSTD::swap(__first_, __t.__first_);
+            _VSTD::swap(__begin_, __t.__begin_);
+            _VSTD::swap(__end_, __t.__end_);
+            _VSTD::swap(__end_cap(), __t.__end_cap());
 #ifndef _LIBCPP_NO_EXCEPTIONS
         }
         catch (...)
@@ -481,7 +481,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
         {
             difference_type __d = __end_cap() - __end_;
             __d = (__d + 1) / 2;
-            __begin_ = _STD::move_backward(__begin_, __end_, __end_ + __d);
+            __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
             __end_ += __d;
         }
         else
@@ -490,13 +490,13 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
             __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
-            _STD::swap(__first_, __t.__first_);
-            _STD::swap(__begin_, __t.__begin_);
-            _STD::swap(__end_, __t.__end_);
-            _STD::swap(__end_cap(), __t.__end_cap());
+            _VSTD::swap(__first_, __t.__first_);
+            _VSTD::swap(__begin_, __t.__begin_);
+            _VSTD::swap(__end_, __t.__end_);
+            _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__begin_-1), __x);
+    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1), __x);
     --__begin_;
 }
 
@@ -512,7 +512,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
         {
             difference_type __d = __end_cap() - __end_;
             __d = (__d + 1) / 2;
-            __begin_ = _STD::move_backward(__begin_, __end_, __end_ + __d);
+            __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
             __end_ += __d;
         }
         else
@@ -521,14 +521,14 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
             __split_buffer<value_type, __alloc_rr&> __t(__c, (__c + 3) / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
-            _STD::swap(__first_, __t.__first_);
-            _STD::swap(__begin_, __t.__begin_);
-            _STD::swap(__end_, __t.__end_);
-            _STD::swap(__end_cap(), __t.__end_cap());
+            _VSTD::swap(__first_, __t.__first_);
+            _VSTD::swap(__begin_, __t.__begin_);
+            _VSTD::swap(__end_, __t.__end_);
+            _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__begin_-1),
-            _STD::move(__x));
+    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1),
+            _VSTD::move(__x));
     --__begin_;
 }
 
@@ -545,7 +545,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
         {
             difference_type __d = __begin_ - __first_;
             __d = (__d + 1) / 2;
-            __end_ = _STD::move(__begin_, __end_, __begin_ - __d);
+            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
             __begin_ -= __d;
         }
         else
@@ -554,13 +554,13 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
             __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
-            _STD::swap(__first_, __t.__first_);
-            _STD::swap(__begin_, __t.__begin_);
-            _STD::swap(__end_, __t.__end_);
-            _STD::swap(__end_cap(), __t.__end_cap());
+            _VSTD::swap(__first_, __t.__first_);
+            _VSTD::swap(__begin_, __t.__begin_);
+            _VSTD::swap(__end_, __t.__end_);
+            _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_), __x);
+    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), __x);
     ++__end_;
 }
 
@@ -576,7 +576,7 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
         {
             difference_type __d = __begin_ - __first_;
             __d = (__d + 1) / 2;
-            __end_ = _STD::move(__begin_, __end_, __begin_ - __d);
+            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
             __begin_ -= __d;
         }
         else
@@ -585,14 +585,14 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
             __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
-            _STD::swap(__first_, __t.__first_);
-            _STD::swap(__begin_, __t.__begin_);
-            _STD::swap(__end_, __t.__end_);
-            _STD::swap(__end_cap(), __t.__end_cap());
+            _VSTD::swap(__first_, __t.__first_);
+            _VSTD::swap(__begin_, __t.__begin_);
+            _VSTD::swap(__end_, __t.__end_);
+            _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_),
-            _STD::move(__x));
+    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
+            _VSTD::move(__x));
     ++__end_;
 }
 
@@ -609,7 +609,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
         {
             difference_type __d = __begin_ - __first_;
             __d = (__d + 1) / 2;
-            __end_ = _STD::move(__begin_, __end_, __begin_ - __d);
+            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
             __begin_ -= __d;
         }
         else
@@ -618,14 +618,14 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
             __split_buffer<value_type, __alloc_rr&> __t(__c, __c / 4, __alloc());
             __t.__construct_at_end(move_iterator<pointer>(__begin_),
                                    move_iterator<pointer>(__end_));
-            _STD::swap(__first_, __t.__first_);
-            _STD::swap(__begin_, __t.__begin_);
-            _STD::swap(__end_, __t.__end_);
-            _STD::swap(__end_cap(), __t.__end_cap());
+            _VSTD::swap(__first_, __t.__first_);
+            _VSTD::swap(__begin_, __t.__begin_);
+            _VSTD::swap(__end_, __t.__end_);
+            _VSTD::swap(__end_cap(), __t.__end_cap());
         }
     }
-    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_),
-                              _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
+                              _VSTD::forward<_Args>(__args)...);
     ++__end_;
 }
 

include/__std_stream

@@ -97,7 +97,7 @@ typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
     char __extbuf[__limit];
-    int __nread = _STD::max(1, __encoding_);
+    int __nread = _VSTD::max(1, __encoding_);
     for (int __i = 0; __i < __nread; ++__i)
     {
         char __c = getc(__file_);
@@ -120,7 +120,7 @@ __stdinbuf<_CharT>::__getchar(bool __consume)
                                    &__1buf, &__1buf + 1, __inxt);
             switch (__r)
             {
-            case _STD::codecvt_base::ok:
+            case _VSTD::codecvt_base::ok:
                 break;
             case codecvt_base::partial:
                 __st_ = __sv_st;
@@ -136,11 +136,11 @@ __stdinbuf<_CharT>::__getchar(bool __consume)
                 break;
             case codecvt_base::error:
                 return traits_type::eof();
-            case _STD::codecvt_base::noconv:
+            case _VSTD::codecvt_base::noconv:
                 __1buf = static_cast<char_type>(__extbuf[0]);
                 break;
             }
-        } while (__r == _STD::codecvt_base::partial);
+        } while (__r == _VSTD::codecvt_base::partial);
     }
     if (!__consume)
     {
@@ -166,9 +166,9 @@ __stdinbuf<_CharT>::pbackfail(int_type __c)
     switch (__cv_->out(__st_, &__ci, &__ci + 1, __inxt,
                               __extbuf, __extbuf + sizeof(__extbuf), __enxt))
     {
-    case _STD::codecvt_base::ok:
+    case _VSTD::codecvt_base::ok:
         break;
-    case _STD::codecvt_base::noconv:
+    case _VSTD::codecvt_base::noconv:
         __extbuf[0] = static_cast<char>(__c);
         __enxt = __extbuf + 1;
         break;

include/__tree

@@ -21,13 +21,19 @@
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class, class, class> class __tree;
-template <class, class, class> class _LIBCPP_VISIBLE __tree_iterator;
-template <class, class, class> class _LIBCPP_VISIBLE __tree_const_iterator;
-template <class, class, class, class> class _LIBCPP_VISIBLE map;
-template <class, class, class, class> class _LIBCPP_VISIBLE multimap;
-template <class, class, class> class _LIBCPP_VISIBLE set;
-template <class, class, class> class _LIBCPP_VISIBLE multiset;
+template <class _Tp, class _Compare, class _Allocator> class __tree;
+template <class _Tp, class _NodePtr, class _DiffType>
+    class _LIBCPP_VISIBLE __tree_iterator;
+template <class _Tp, class _ConstNodePtr, class _DiffType>
+    class _LIBCPP_VISIBLE __tree_const_iterator;
+template <class _Key, class _Tp, class _Compare, class _Allocator>
+    class _LIBCPP_VISIBLE map;
+template <class _Key, class _Tp, class _Compare, class _Allocator>
+    class _LIBCPP_VISIBLE multimap;
+template <class _Key, class _Compare, class _Allocator>
+    class _LIBCPP_VISIBLE set;
+template <class _Key, class _Compare, class _Allocator>
+    class _LIBCPP_VISIBLE multiset;
 
 /*
 
@@ -494,7 +500,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
     }
 }
 
-template <class> class __map_node_destructor;
+template <class _Allocator> class __map_node_destructor;
 
 template <class _Allocator>
 class __tree_node_destructor
@@ -523,7 +529,7 @@ public:
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__value_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
@@ -598,7 +604,7 @@ public:
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tree_node(_Args&& ...__args)
-            : __value_(_STD::forward<_Args>(__args)...) {}
+            : __value_(_VSTD::forward<_Args>(__args)...) {}
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY
     explicit __tree_node(const value_type& __v)
@@ -606,8 +612,8 @@ public:
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
 };
 
-template <class> class __map_iterator;
-template <class> class __map_const_iterator;
+template <class _TreeIterator> class __map_iterator;
+template <class _TreeIterator> class __map_const_iterator;
 
 template <class _Tp, class _NodePtr, class _DiffType>
 class _LIBCPP_VISIBLE __tree_iterator
@@ -1069,7 +1075,7 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__tree& __t, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {__node_alloc() = _STD::move(__t.__node_alloc());}
+        {__node_alloc() = _VSTD::move(__t.__node_alloc());}
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__tree& __t, false_type) _NOEXCEPT {}
 
@@ -1084,7 +1090,7 @@ private:
     static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
     _LIBCPP_INLINE_VISIBILITY
@@ -1278,9 +1284,9 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
     _NOEXCEPT_(
         is_nothrow_move_constructible<__node_allocator>::value &&
         is_nothrow_move_constructible<value_compare>::value)
-    : __begin_node_(_STD::move(__t.__begin_node_)),
-      __pair1_(_STD::move(__t.__pair1_)),
-      __pair3_(_STD::move(__t.__pair3_))
+    : __begin_node_(_VSTD::move(__t.__begin_node_)),
+      __pair1_(_VSTD::move(__t.__pair1_)),
+      __pair3_(_VSTD::move(__t.__pair3_))
 {
     if (size() == 0)
         __begin_node() = __end_node();
@@ -1296,7 +1302,7 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __a)
     : __pair1_(__node_allocator(__a)),
-      __pair3_(0, _STD::move(__t.value_comp()))
+      __pair3_(0, _VSTD::move(__t.value_comp()))
 {
     if (__a == __t.__alloc())
     {
@@ -1329,7 +1335,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
     __begin_node_ = __t.__begin_node_;
     __pair1_.first() = __t.__pair1_.first();
     __move_assign_alloc(__t);
-    __pair3_ = _STD::move(__t.__pair3_);
+    __pair3_ = _VSTD::move(__t.__pair3_);
     if (size() == 0)
         __begin_node() = __end_node();
     else
@@ -1349,7 +1355,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
         __move_assign(__t, true_type());
     else
     {
-        value_comp() = _STD::move(__t.value_comp());
+        value_comp() = _VSTD::move(__t.value_comp());
         const_iterator __e = end();
         if (size() != 0)
         {
@@ -1360,7 +1366,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
 #endif  // _LIBCPP_NO_EXCEPTIONS
                 while (__cache != nullptr && __t.size() != 0)
                 {
-                    __cache->__value_ = _STD::move(__t.remove(__t.begin())->__value_);
+                    __cache->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
                     __node_pointer __next = __detach(__cache);
                     __node_insert_multi(__cache);
                     __cache = __next;
@@ -1383,7 +1389,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
             }
         }
         while (__t.size() != 0)
-            __insert_multi(__e, _STD::move(__t.remove(__t.begin())->__value_));
+            __insert_multi(__e, _VSTD::move(__t.remove(__t.begin())->__value_));
     }
 }
 
@@ -1418,7 +1424,7 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
         destroy(static_cast<__node_pointer>(__nd->__left_));
         destroy(static_cast<__node_pointer>(__nd->__right_));
         __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, _STD::addressof(__nd->__value_));
+        __node_traits::destroy(__na, _VSTD::addressof(__nd->__value_));
         __node_traits::deallocate(__na, __nd, 1);
     }
 }
@@ -1431,7 +1437,7 @@ __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
         (!__node_traits::propagate_on_container_swap::value ||
          __is_nothrow_swappable<__node_allocator>::value))
 {
-    using _STD::swap;
+    using _VSTD::swap;
     swap(__begin_node_, __t.__begin_node_);
     swap(__pair1_.first(), __t.__pair1_.first());
     __swap_alloc(__node_alloc(), __t.__node_alloc());
@@ -1655,10 +1661,10 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
     else if (value_comp()(*__hint, __v))  // check after
     {
         // *__hint < __v
-        const_iterator __next = _STD::next(__hint);
+        const_iterator __next = _VSTD::next(__hint);
         if (__next == end() || value_comp()(__v, *__next))
         {
-            // *__hint < __v < *_STD::next(__hint)
+            // *__hint < __v < *_VSTD::next(__hint)
             if (__hint.__ptr_->__right_ == nullptr)
             {
                 __parent = const_cast<__node_pointer&>(__hint.__ptr_);
@@ -1704,7 +1710,7 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(_Args&& ...__args)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__value_constructed = true;
     return __h;
 }
@@ -1714,7 +1720,7 @@ template <class... _Args>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__emplace_unique(_Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_equal(__parent, __h->__value_);
     __node_pointer __r = static_cast<__node_pointer>(__child);
@@ -1733,7 +1739,7 @@ template <class... _Args>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__emplace_hint_unique(const_iterator __p, _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_equal(__p, __parent, __h->__value_);
     __node_pointer __r = static_cast<__node_pointer>(__child);
@@ -1750,7 +1756,7 @@ template <class... _Args>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
     __insert_node_at(__parent, __child, __h.get());
@@ -1763,7 +1769,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
                                                         _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
     __insert_node_at(__parent, __child, __h.get());
@@ -1777,7 +1783,7 @@ template <class _V>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(_V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
     pair<iterator, bool> __r = __node_insert_unique(__h.get());
     if (__r.second)
         __h.release();
@@ -1789,7 +1795,7 @@ template <class _V>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
     iterator __r = __node_insert_unique(__p, __h.get());
     if (__r.__ptr_ == __h.get())
         __h.release();
@@ -1801,7 +1807,7 @@ template <class _V>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__insert_multi(_V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
     __insert_node_at(__parent, __child, __h.get());
@@ -1813,7 +1819,7 @@ template <class _V>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, _V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
     __node_base_pointer __parent;
     __node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
     __insert_node_at(__parent, __child, __h.get());
@@ -1828,9 +1834,9 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
 {
     __node_allocator& __na = __node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), __v);
     __h.get_deleter().__value_constructed = true;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1956,7 +1962,7 @@ __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
         __begin_node() = __r.__ptr_;
     --size();
     __node_allocator& __na = __node_alloc();
-    __node_traits::destroy(__na, const_cast<value_type*>(_STD::addressof(*__p)));
+    __node_traits::destroy(__na, const_cast<value_type*>(_VSTD::addressof(*__p)));
     __tree_remove(__end_node()->__left_,
                   static_cast<__node_base_pointer>(__np));
     __node_traits::deallocate(__na, __np, 1);
@@ -2058,7 +2064,7 @@ __tree<_Tp, _Compare, _Allocator>::__count_multi(const _Key& __k) const
         else if (value_comp()(__rt->__value_, __k))
             __rt = static_cast<__node_const_pointer>(__rt->__right_);
         else
-            return _STD::distance(
+            return _VSTD::distance(
                 __lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
                 __upper_bound(__k, static_cast<__node_const_pointer>(__rt->__right_), __result)
             );

include/__tuple

@@ -214,11 +214,7 @@ struct __tuple_convertible_imp : public false_type {};
 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
 struct __tuple_convertible_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
     : public integral_constant<bool,
-#if 1 // waiting on cwg 1170
-                               is_convertible<_Tp0, _Up0>::value &&
-#else
                                is_constructible<_Up0, _Tp0>::value &&
-#endif
                                __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
 
 template <>

include/array

@@ -136,10 +136,10 @@ struct _LIBCPP_VISIBLE array
 
     // No explicit construct/copy/destroy for aggregate type
     _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
-        {_STD::fill_n(__elems_, _Size, __u);}
+        {_VSTD::fill_n(__elems_, _Size, __u);}
     _LIBCPP_INLINE_VISIBILITY
     void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
-        {_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
+        {_VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
 
     // iterators:
     _LIBCPP_INLINE_VISIBILITY
@@ -225,7 +225,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
-    return _STD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
+    return _VSTD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
 }
 
 template <class _Tp, size_t _Size>
@@ -241,7 +241,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
-    return _STD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
+    return _VSTD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
 }
 
 template <class _Tp, size_t _Size>
@@ -326,7 +326,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 _Tp&&
 get(array<_Tp, _Size>&& __a) _NOEXCEPT
 {
-    return _STD::move(__a[_Ip]);
+    return _VSTD::move(__a[_Ip]);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

include/bitset

@@ -129,6 +129,15 @@ template <size_t N> struct hash<std::bitset<N>>;
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+template <size_t _N_words, size_t _Size>
+class __bitset;
+
+template <size_t _N_words, size_t _Size>
+struct __has_storage_type<__bitset<_N_words, _Size> >
+{
+    static const bool value = true;
+};
+
 template <size_t _N_words, size_t _Size>
 class __bitset
 {
@@ -195,7 +204,7 @@ template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 __bitset<_N_words, _Size>::__bitset() _NOEXCEPT
 {
-    _STD::fill_n(__first_, _N_words, __storage_type(0));
+    _VSTD::fill_n(__first_, _N_words, __storage_type(0));
 }
 
 template <size_t _N_words, size_t _Size>
@@ -205,8 +214,8 @@ __bitset<_N_words, _Size>::__init(unsigned long long __v, false_type)
     __storage_type __t[sizeof(unsigned long long) / sizeof(__storage_type)];
     for (size_t __i = 0; __i < sizeof(__t)/sizeof(__t[0]); ++__i, __v >>= __bits_per_word)
         __t[__i] = static_cast<__storage_type>(__v);
-    _STD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
-    _STD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
+    _VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
+    _VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
                __storage_type(0));
 }
 
@@ -216,7 +225,7 @@ void
 __bitset<_N_words, _Size>::__init(unsigned long long __v, true_type)
 {
     __first_[0] = __v;
-    _STD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
+    _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
 }
 
 template <size_t _N_words, size_t _Size>
@@ -277,7 +286,7 @@ unsigned long
 __bitset<_N_words, _Size>::to_ulong(false_type) const
 {
     const_iterator __e = __make_iter(_Size);
-    const_iterator __i = _STD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
+    const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
     if (__i != __e)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw overflow_error("bitset to_ulong overflow error");
@@ -300,7 +309,7 @@ unsigned long long
 __bitset<_N_words, _Size>::to_ullong(false_type) const
 {
     const_iterator __e = __make_iter(_Size);
-    const_iterator __i = _STD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
+    const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
     if (__i != __e)
 #ifndef _LIBCPP_NO_EXCEPTIONS
         throw overflow_error("bitset to_ullong overflow error");
@@ -674,7 +683,7 @@ bitset<_Size>::bitset(const _CharT* __str,
                       typename basic_string<_CharT>::size_type __n,
                       _CharT __zero, _CharT __one)
 {
-    size_t __rlen = _STD::min(__n, char_traits<_CharT>::length(__str));
+    size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
     for (size_t __i = 0; __i < __rlen; ++__i)
         if (__str[__i] != __zero && __str[__i] != __one)
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -682,7 +691,7 @@ bitset<_Size>::bitset(const _CharT* __str,
 #else
             assert(!"bitset string ctor has invalid argument");
 #endif
-    size_t _M = _STD::min(__rlen, _Size);
+    size_t _M = _VSTD::min(__rlen, _Size);
     size_t __i = 0;
     for (; __i < _M; ++__i)
     {
@@ -692,7 +701,7 @@ bitset<_Size>::bitset(const _CharT* __str,
         else
             (*this)[__i] = true;
     }
-    _STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+    _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
 
 template <size_t _Size>
@@ -708,7 +717,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
 #else
         assert(!"bitset string pos out of range");
 #endif
-    size_t __rlen = _STD::min(__n, __str.size() - __pos);
+    size_t __rlen = _VSTD::min(__n, __str.size() - __pos);
     for (size_t __i = __pos; __i < __pos + __rlen; ++__i)
         if (!_Traits::eq(__str[__i], __zero) && !_Traits::eq(__str[__i], __one))
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -716,7 +725,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
 #else
             assert(!"bitset string ctor has invalid argument");
 #endif
-    size_t _M = _STD::min(__rlen, _Size);
+    size_t _M = _VSTD::min(__rlen, _Size);
     size_t __i = 0;
     for (; __i < _M; ++__i)
     {
@@ -726,7 +735,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
         else
             (*this)[__i] = true;
     }
-    _STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+    _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
 
 template <size_t _Size>
@@ -760,9 +769,9 @@ template <size_t _Size>
 bitset<_Size>&
 bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
 {
-    __pos = _STD::min(__pos, _Size);
-    _STD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
-    _STD::fill_n(base::__make_iter(0), __pos, false);
+    __pos = _VSTD::min(__pos, _Size);
+    _VSTD::copy_backward(base::__make_iter(0), base::__make_iter(_Size - __pos), base::__make_iter(_Size));
+    _VSTD::fill_n(base::__make_iter(0), __pos, false);
     return *this;
 }
 
@@ -770,9 +779,9 @@ template <size_t _Size>
 bitset<_Size>&
 bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
 {
-    __pos = _STD::min(__pos, _Size);
-    _STD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
-    _STD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
+    __pos = _VSTD::min(__pos, _Size);
+    _VSTD::copy(base::__make_iter(__pos), base::__make_iter(_Size), base::__make_iter(0));
+    _VSTD::fill_n(base::__make_iter(_Size - __pos), __pos, false);
     return *this;
 }
 
@@ -781,7 +790,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
 bitset<_Size>::set() _NOEXCEPT
 {
-    _STD::fill_n(base::__make_iter(0), _Size, true);
+    _VSTD::fill_n(base::__make_iter(0), _Size, true);
     return *this;
 }
 
@@ -804,7 +813,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
 bitset<_Size>::reset() _NOEXCEPT
 {
-    _STD::fill_n(base::__make_iter(0), _Size, false);
+    _VSTD::fill_n(base::__make_iter(0), _Size, false);
     return *this;
 }
 
@@ -917,7 +926,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 size_t
 bitset<_Size>::count() const _NOEXCEPT
 {
-    return static_cast<size_t>(_STD::count(base::__make_iter(0), base::__make_iter(_Size), true));
+    return static_cast<size_t>(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true));
 }
 
 template <size_t _Size>
@@ -925,7 +934,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
 {
-    return _STD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
+    return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
 }
 
 template <size_t _Size>

include/chrono

@@ -407,7 +407,7 @@ public:
                 (ratio_divide<_Period2, period>::type::den == 1 &&
                  !treat_as_floating_point<_Rep2>::value)
             >::type* = 0)
-                : __rep_(_STD::chrono::duration_cast<duration>(__d).count()) {}
+                : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
 
     // observer
 
@@ -726,7 +726,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 time_point<_Clock, _ToDuration>
 time_point_cast(const time_point<_Clock, _Duration>& __t)
 {
-    return time_point<_Clock, _ToDuration>(_STD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
+    return time_point<_Clock, _ToDuration>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 }
 
 // time_point ==

include/complex

@@ -1173,7 +1173,7 @@ complex<typename __promote<_Tp, _Up>::type>
 pow(const complex<_Tp>& __x, const complex<_Up>& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
-    return _STD::pow(result_type(__x), result_type(__y));
+    return _VSTD::pow(result_type(__x), result_type(__y));
 }
 
 template<class _Tp, class _Up>
@@ -1186,7 +1186,7 @@ typename enable_if
 pow(const complex<_Tp>& __x, const _Up& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
-    return _STD::pow(result_type(__x), result_type(__y));
+    return _VSTD::pow(result_type(__x), result_type(__y));
 }
 
 template<class _Tp, class _Up>
@@ -1199,7 +1199,7 @@ typename enable_if
 pow(const _Tp& __x, const complex<_Up>& __y)
 {
     typedef complex<typename __promote<_Tp, _Up>::type> result_type;
-    return _STD::pow(result_type(__x), result_type(__y));
+    return _VSTD::pow(result_type(__x), result_type(__y));
 }
 
 // asinh

include/condition_variable

@@ -243,7 +243,7 @@ condition_variable_any::wait_for(_Lock& __lock,
                                  _Predicate __pred)
 {
     return wait_until(__lock, chrono::steady_clock::now() + __d,
-                      _STD::move(__pred));
+                      _VSTD::move(__pred));
 }
 
 _LIBCPP_VISIBLE

include/cstddef

@@ -82,7 +82,7 @@ struct _LIBCPP_VISIBLE nullptr_t
 
 inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}
 
-#define nullptr _STD::__get_nullptr_t()
+#define nullptr _VSTD::__get_nullptr_t()
 
 #endif  // _LIBCPP_HAS_NO_NULLPTR
 

include/deque

@@ -535,7 +535,7 @@ copy(_RAIter __f,
             __n = __bs;
             __m = __f + __n;
         }
-        _STD::copy(__f, __m, __rb);
+        _VSTD::copy(__f, __m, __rb);
         __f = __m;
         __r += __n;
     }
@@ -562,7 +562,7 @@ copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __fe = __fb + __bs;
         }
-        __r = _STD::copy(__fb, __fe, __r);
+        __r = _VSTD::copy(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
@@ -589,7 +589,7 @@ copy(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __fe = __fb + __bs;
         }
-        __r = _STD::copy(__fb, __fe, __r);
+        __r = _VSTD::copy(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
@@ -610,7 +610,7 @@ copy_backward(_RAIter __f,
     typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
     while (__f != __l)
     {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
         pointer __rb = *__rp.__m_iter_;
         pointer __re = __rp.__ptr_ + 1;
         difference_type __bs = __re - __rb;
@@ -621,7 +621,7 @@ copy_backward(_RAIter __f,
             __n = __bs;
             __m = __l - __n;
         }
-        _STD::copy_backward(__m, __l, __re);
+        _VSTD::copy_backward(__m, __l, __re);
         __l = __m;
         __r -= __n;
     }
@@ -649,7 +649,7 @@ copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __lb = __le - __bs;
         }
-        __r = _STD::copy_backward(__lb, __le, __r);
+        __r = _VSTD::copy_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
@@ -677,7 +677,7 @@ copy_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __lb = __le - __bs;
         }
-        __r = _STD::copy_backward(__lb, __le, __r);
+        __r = _VSTD::copy_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
@@ -708,7 +708,7 @@ move(_RAIter __f,
             __n = __bs;
             __m = __f + __n;
         }
-        _STD::move(__f, __m, __rb);
+        _VSTD::move(__f, __m, __rb);
         __f = __m;
         __r += __n;
     }
@@ -735,7 +735,7 @@ move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __fe = __fb + __bs;
         }
-        __r = _STD::move(__fb, __fe, __r);
+        __r = _VSTD::move(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
@@ -762,7 +762,7 @@ move(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __fe = __fb + __bs;
         }
-        __r = _STD::move(__fb, __fe, __r);
+        __r = _VSTD::move(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
@@ -783,7 +783,7 @@ move_backward(_RAIter __f,
     typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
     while (__f != __l)
     {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _VSTD::prev(__r);
         pointer __rb = *__rp.__m_iter_;
         pointer __re = __rp.__ptr_ + 1;
         difference_type __bs = __re - __rb;
@@ -794,7 +794,7 @@ move_backward(_RAIter __f,
             __n = __bs;
             __m = __l - __n;
         }
-        _STD::move_backward(__m, __l, __re);
+        _VSTD::move_backward(__m, __l, __re);
         __l = __m;
         __r -= __n;
     }
@@ -822,7 +822,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __lb = __le - __bs;
         }
-        __r = _STD::move_backward(__lb, __le, __r);
+        __r = _VSTD::move_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
@@ -850,7 +850,7 @@ move_backward(__deque_iterator<_V1, _P1, _R1, _M1, _D1, _B1> __f,
             __bs = __n;
             __lb = __le - __bs;
         }
-        __r = _STD::move_backward(__lb, __le, __r);
+        __r = _VSTD::move_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
@@ -961,7 +961,7 @@ protected:
         _NOEXCEPT_(__alloc_traits::propagate_on_container_move_assignment::value &&
                    is_nothrow_move_assignable<allocator_type>::value)
     {
-        __map_ = _STD::move(__c.__map_);
+        __map_ = _VSTD::move(__c.__map_);
         __start_ = __c.__start_;
         size() = __c.size();
         __move_assign_alloc(__c);
@@ -980,7 +980,7 @@ private:
     void __move_assign_alloc(const __deque_base& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
-            __alloc() = _STD::move(__c.__alloc());
+            __alloc() = _VSTD::move(__c.__alloc());
         }
 
     _LIBCPP_INLINE_VISIBILITY
@@ -998,7 +998,7 @@ private:
     static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
 
@@ -1097,9 +1097,9 @@ __deque_base<_Tp, _Allocator>::~__deque_base()
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-    : __map_(_STD::move(__c.__map_)),
-      __start_(_STD::move(__c.__start_)),
-      __size_(_STD::move(__c.__size_))
+    : __map_(_VSTD::move(__c.__map_)),
+      __start_(_VSTD::move(__c.__start_)),
+      __size_(_VSTD::move(__c.__size_))
 {
     __c.__start_ = 0;
     __c.size() = 0;
@@ -1107,9 +1107,9 @@ __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c)
 
 template <class _Tp, class _Allocator>
 __deque_base<_Tp, _Allocator>::__deque_base(__deque_base&& __c, const allocator_type& __a)
-    : __map_(_STD::move(__c.__map_), __pointer_allocator(__a)),
-      __start_(_STD::move(__c.__start_)),
-      __size_(_STD::move(__c.size()), __a)
+    : __map_(_VSTD::move(__c.__map_), __pointer_allocator(__a)),
+      __start_(_VSTD::move(__c.__start_)),
+      __size_(_VSTD::move(__c.size()), __a)
 {
     if (__a == __c.__alloc())
     {
@@ -1133,8 +1133,8 @@ __deque_base<_Tp, _Allocator>::swap(__deque_base& __c)
                    __is_nothrow_swappable<allocator_type>::value)
 {
     __map_.swap(__c.__map_);
-    _STD::swap(__start_, __c.__start_);
-    _STD::swap(size(), __c.size());
+    _VSTD::swap(__start_, __c.__start_);
+    _VSTD::swap(size(), __c.size());
     __swap_alloc(__alloc(), __c.__alloc());
 }
 
@@ -1144,7 +1144,7 @@ __deque_base<_Tp, _Allocator>::clear() _NOEXCEPT
 {
     allocator_type& __a = __alloc();
     for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
-        __alloc_traits::destroy(__a, _STD::addressof(*__i));
+        __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
     size() = 0;
     while (__map_.size() > 2)
     {
@@ -1184,8 +1184,8 @@ public:
 
     typedef typename __base::pointer               pointer;
     typedef typename __base::const_pointer         const_pointer;
-    typedef _STD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
@@ -1483,14 +1483,14 @@ template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 deque<_Tp, _Allocator>::deque(deque&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-    : __base(_STD::move(__c))
+    : __base(_VSTD::move(__c))
 {
 }
 
 template <class _Tp, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 deque<_Tp, _Allocator>::deque(deque&& __c, const allocator_type& __a)
-    : __base(_STD::move(__c), __a)
+    : __base(_VSTD::move(__c), __a)
 {
     if (__a != __c.__alloc())
     {
@@ -1562,11 +1562,11 @@ deque<_Tp, _Allocator>::assign(_RAIter __f, _RAIter __l,
     if (static_cast<size_type>(__l - __f) > __base::size())
     {
         _RAIter __m = __f + __base::size();
-        _STD::copy(__f, __m, __base::begin());
+        _VSTD::copy(__f, __m, __base::begin());
         __append(__m, __l);
     }
     else
-        __erase_to_end(_STD::copy(__f, __l, __base::begin()));
+        __erase_to_end(_VSTD::copy(__f, __l, __base::begin()));
 }
 
 template <class _Tp, class _Allocator>
@@ -1575,12 +1575,12 @@ deque<_Tp, _Allocator>::assign(size_type __n, const value_type& __v)
 {
     if (__n > __base::size())
     {
-        _STD::fill_n(__base::begin(), __base::size(), __v);
+        _VSTD::fill_n(__base::begin(), __base::size(), __v);
         __n -= __base::size();
         __append(__n, __v);
     }
     else
-        __erase_to_end(_STD::fill_n(__base::begin(), __n, __v));
+        __erase_to_end(_VSTD::fill_n(__base::begin(), __n, __v));
 }
 
 template <class _Tp, class _Allocator>
@@ -1726,7 +1726,7 @@ deque<_Tp, _Allocator>::push_back(const value_type& __v)
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
+    __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
     ++__base::size();
 }
 
@@ -1740,7 +1740,7 @@ deque<_Tp, _Allocator>::push_back(value_type&& __v)
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
+    __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
     ++__base::size();
 }
 
@@ -1755,7 +1755,7 @@ deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
     if (__back_spare() == 0)
         __add_back_capacity();
     // __back_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
     ++__base::size();
 }
 
@@ -1770,7 +1770,7 @@ deque<_Tp, _Allocator>::push_front(const value_type& __v)
     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
+    __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
     --__base::__start_;
     ++__base::size();
 }
@@ -1785,7 +1785,7 @@ deque<_Tp, _Allocator>::push_front(value_type&& __v)
     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
+    __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
     --__base::__start_;
     ++__base::size();
 }
@@ -1801,7 +1801,7 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
     if (__front_spare() == 0)
         __add_front_capacity();
     // __front_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
     --__base::__start_;
     ++__base::size();
 }
@@ -1823,7 +1823,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
         // __front_spare() >= 1
         if (__pos == 0)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
+            __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), __v);
             --__base::__start_;
             ++__base::size();
         }
@@ -1831,14 +1831,14 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
         {
             const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
             iterator __b = __base::begin();
-            iterator __bm1 = _STD::prev(__b);
+            iterator __bm1 = _VSTD::prev(__b);
             if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
                 __vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
-            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
+            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
             --__base::__start_;
             ++__base::size();
             if (__pos > 1)
-                __b = __move_and_check(_STD::next(__b), __b + __pos, __b, __vt);
+                __b = __move_and_check(_VSTD::next(__b), __b + __pos, __b, __vt);
             *__b = *__vt;
         }
     }
@@ -1850,17 +1850,17 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
         size_type __de = __base::size() - __pos;
         if (__de == 0)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
+            __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), __v);
             ++__base::size();
         }
         else
         {
             const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
             iterator __e = __base::end();
-            iterator __em1 = _STD::prev(__e);
+            iterator __em1 = _VSTD::prev(__e);
             if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
                 __vt = pointer_traits<const_pointer>::pointer_to(*__e);
-            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
+            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
             ++__base::size();
             if (__de > 1)
                 __e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
@@ -1886,20 +1886,20 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
         // __front_spare() >= 1
         if (__pos == 0)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
+            __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::move(__v));
             --__base::__start_;
             ++__base::size();
         }
         else
         {
             iterator __b = __base::begin();
-            iterator __bm1 = _STD::prev(__b);
-            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
+            iterator __bm1 = _VSTD::prev(__b);
+            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
             --__base::__start_;
             ++__base::size();
             if (__pos > 1)
-                __b = _STD::move(_STD::next(__b), __b + __pos, __b);
-            *__b = _STD::move(__v);
+                __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
+            *__b = _VSTD::move(__v);
         }
     }
     else
@@ -1910,18 +1910,18 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
         size_type __de = __base::size() - __pos;
         if (__de == 0)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
+            __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::move(__v));
             ++__base::size();
         }
         else
         {
             iterator __e = __base::end();
-            iterator __em1 = _STD::prev(__e);
-            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
+            iterator __em1 = _VSTD::prev(__e);
+            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
             ++__base::size();
             if (__de > 1)
-                __e = _STD::move_backward(__e - __de, __em1, __e);
-            *--__e = _STD::move(__v);
+                __e = _VSTD::move_backward(__e - __de, __em1, __e);
+            *--__e = _VSTD::move(__v);
         }
     }
     return __base::begin() + __pos;
@@ -1944,20 +1944,20 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
         // __front_spare() >= 1
         if (__pos == 0)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
+            __alloc_traits::construct(__a, _VSTD::addressof(*--__base::begin()), _VSTD::forward<_Args>(__args)...);
             --__base::__start_;
             ++__base::size();
         }
         else
         {
             iterator __b = __base::begin();
-            iterator __bm1 = _STD::prev(__b);
-            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
+            iterator __bm1 = _VSTD::prev(__b);
+            __alloc_traits::construct(__a, _VSTD::addressof(*__bm1), _VSTD::move(*__b));
             --__base::__start_;
             ++__base::size();
             if (__pos > 1)
-                __b = _STD::move(_STD::next(__b), __b + __pos, __b);
-            *__b = value_type(_STD::forward<_Args>(__args)...);
+                __b = _VSTD::move(_VSTD::next(__b), __b + __pos, __b);
+            *__b = value_type(_VSTD::forward<_Args>(__args)...);
         }
     }
     else
@@ -1968,18 +1968,18 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
         size_type __de = __base::size() - __pos;
         if (__de == 0)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
+            __alloc_traits::construct(__a, _VSTD::addressof(*__base::end()), _VSTD::forward<_Args>(__args)...);
             ++__base::size();
         }
         else
         {
             iterator __e = __base::end();
-            iterator __em1 = _STD::prev(__e);
-            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
+            iterator __em1 = _VSTD::prev(__e);
+            __alloc_traits::construct(__a, _VSTD::addressof(*__e), _VSTD::move(*__em1));
             ++__base::size();
             if (__de > 1)
-                __e = _STD::move_backward(__e - __de, __em1, __e);
-            *--__e = value_type(_STD::forward<_Args>(__args)...);
+                __e = _VSTD::move_backward(__e - __de, __em1, __e);
+            *--__e = value_type(_VSTD::forward<_Args>(__args)...);
         }
     }
     return __base::begin() + __pos;
@@ -2006,7 +2006,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
         if (__n > __pos)
         {
             for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*--__i), __v);
+                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), __v);
             __n = __pos;
         }
         if (__n > 0)
@@ -2016,7 +2016,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
             __move_construct_backward_and_check(__old_begin, __obn, __i, __vt);
             if (__n < __pos)
                 __old_begin = __move_and_check(__obn, __old_begin + __pos, __old_begin, __vt);
-            _STD::fill_n(__old_begin, __n, *__vt);
+            _VSTD::fill_n(__old_begin, __n, *__vt);
         }
     }
     else
@@ -2032,7 +2032,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
         if (__n > __de)
         {
             for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*__i), __v);
+                __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
             __n = __de;
         }
         if (__n > 0)
@@ -2042,7 +2042,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
             __move_construct_and_check(__oen, __old_end, __i, __vt);
             if (__n < __de)
                 __old_end = __move_backward_and_check(__old_end - __de, __oen, __old_end, __vt);
-            _STD::fill_n(__old_end - __n, __n, *__vt);
+            _VSTD::fill_n(__old_end - __n, __n, *__vt);
         }
     }
     return __base::begin() + __pos;
@@ -2067,7 +2067,7 @@ typename deque<_Tp, _Allocator>::iterator
 deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
                                typename enable_if<__is_bidirectional_iterator<_BiIter>::value>::type*)
 {
-    size_type __n = _STD::distance(__f, __l);
+    size_type __n = _VSTD::distance(__f, __l);
     size_type __pos = __p - __base::begin();
     size_type __to_end = __base::size() - __pos;
     allocator_type& __a = __base::__alloc();
@@ -2082,9 +2082,9 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
         _BiIter __m = __f;
         if (__n > __pos)
         {
-            __m = __pos < __n / 2 ? _STD::prev(__l, __pos) : _STD::next(__f, __n - __pos);
+            __m = __pos < __n / 2 ? _VSTD::prev(__l, __pos) : _VSTD::next(__f, __n - __pos);
             for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*--__i), *--__j);
+                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), *--__j);
             __n = __pos;
         }
         if (__n > 0)
@@ -2092,13 +2092,13 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
             iterator __obn = __old_begin + __n;
             for (iterator __j = __obn; __j != __old_begin;)
             {
-                __alloc_traits::construct(__a, _STD::addressof(*--__i), _STD::move(*--__j));
+                __alloc_traits::construct(__a, _VSTD::addressof(*--__i), _VSTD::move(*--__j));
                 --__base::__start_;
                 ++__base::size();
             }
             if (__n < __pos)
-                __old_begin = _STD::move(__obn, __old_begin + __pos, __old_begin);
-            _STD::copy(__m, __l, __old_begin);
+                __old_begin = _VSTD::move(__obn, __old_begin + __pos, __old_begin);
+            _VSTD::copy(__m, __l, __old_begin);
         }
     }
     else
@@ -2114,19 +2114,19 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
         size_type __de = __base::size() - __pos;
         if (__n > __de)
         {
-            __m = __de < __n / 2 ? _STD::next(__f, __de) : _STD::prev(__l, __n - __de);
+            __m = __de < __n / 2 ? _VSTD::next(__f, __de) : _VSTD::prev(__l, __n - __de);
             for (_BiIter __j = __m; __j != __l; ++__i, ++__j, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*__i), *__j);
+                __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__j);
             __n = __de;
         }
         if (__n > 0)
         {
             iterator __oen = __old_end - __n;
             for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*__i), _STD::move(*__j));
+                __alloc_traits::construct(__a, _VSTD::addressof(*__i), _VSTD::move(*__j));
             if (__n < __de)
-                __old_end = _STD::move_backward(__old_end - __de, __oen, __old_end);
-            _STD::copy_backward(__f, __m, __old_end);
+                __old_end = _VSTD::move_backward(__old_end - __de, __oen, __old_end);
+            _VSTD::copy_backward(__f, __m, __old_end);
         }
     }
     return __base::begin() + __pos;
@@ -2149,14 +2149,14 @@ void
 deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
                                  typename enable_if<__is_forward_iterator<_ForIter>::value>::type*)
 {
-    size_type __n = _STD::distance(__f, __l);
+    size_type __n = _VSTD::distance(__f, __l);
     allocator_type& __a = __base::__alloc();
     size_type __back_capacity = __back_spare();
     if (__n > __back_capacity)
         __add_back_capacity(__n - __back_capacity);
     // __n <= __back_capacity
     for (iterator __i = __base::end(); __f != __l; ++__i, ++__f, ++__base::size())
-        __alloc_traits::construct(__a, _STD::addressof(*__i), *__f);
+        __alloc_traits::construct(__a, _VSTD::addressof(*__i), *__f);
 }
 
 template <class _Tp, class _Allocator>
@@ -2169,7 +2169,7 @@ deque<_Tp, _Allocator>::__append(size_type __n)
         __add_back_capacity(__n - __back_capacity);
     // __n <= __back_capacity
     for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
-        __alloc_traits::construct(__a, _STD::addressof(*__i));
+        __alloc_traits::construct(__a, _VSTD::addressof(*__i));
 }
 
 template <class _Tp, class _Allocator>
@@ -2182,7 +2182,7 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
         __add_back_capacity(__n - __back_capacity);
     // __n <= __back_capacity
     for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
-        __alloc_traits::construct(__a, _STD::addressof(*__i), __v);
+        __alloc_traits::construct(__a, _VSTD::addressof(*__i), __v);
 }
 
 // Create front capacity for one block of elements.
@@ -2240,10 +2240,10 @@ deque<_Tp, _Allocator>::__add_front_capacity()
         for (typename __base::__map_pointer __i = __base::__map_.begin();
                 __i != __base::__map_.end(); ++__i)
             __buf.push_back(*__i);
-        _STD::swap(__base::__map_.__first_, __buf.__first_);
-        _STD::swap(__base::__map_.__begin_, __buf.__begin_);
-        _STD::swap(__base::__map_.__end_, __buf.__end_);
-        _STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
+        _VSTD::swap(__base::__map_.__first_, __buf.__first_);
+        _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
+        _VSTD::swap(__base::__map_.__end_, __buf.__end_);
+        _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
         __base::__start_ = __base::__map_.size() == 1 ?
                                __base::__block_size / 2 :
                                __base::__start_ + __base::__block_size;
@@ -2260,7 +2260,7 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
     size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
     // Number of unused blocks at back:
     size_type __back_capacity = __back_spare() / __base::__block_size;
-    __back_capacity = _STD::min(__back_capacity, __nb);  // don't take more than you need
+    __back_capacity = _VSTD::min(__back_capacity, __nb);  // don't take more than you need
     __nb -= __back_capacity;  // number of blocks need to allocate
     // If __nb == 0, then we have sufficient capacity.
     if (__nb == 0)
@@ -2327,10 +2327,10 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
         for (typename __base::__map_pointer __i = __base::__map_.begin();
                 __i != __base::__map_.end(); ++__i)
             __buf.push_back(*__i);
-        _STD::swap(__base::__map_.__first_, __buf.__first_);
-        _STD::swap(__base::__map_.__begin_, __buf.__begin_);
-        _STD::swap(__base::__map_.__end_, __buf.__end_);
-        _STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
+        _VSTD::swap(__base::__map_.__first_, __buf.__first_);
+        _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
+        _VSTD::swap(__base::__map_.__end_, __buf.__end_);
+        _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
         __base::__start_ += __ds;
     }
 }
@@ -2388,10 +2388,10 @@ deque<_Tp, _Allocator>::__add_back_capacity()
         for (typename __base::__map_pointer __i = __base::__map_.end();
                 __i != __base::__map_.begin();)
             __buf.push_front(*--__i);
-        _STD::swap(__base::__map_.__first_, __buf.__first_);
-        _STD::swap(__base::__map_.__begin_, __buf.__begin_);
-        _STD::swap(__base::__map_.__end_, __buf.__end_);
-        _STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
+        _VSTD::swap(__base::__map_.__first_, __buf.__first_);
+        _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
+        _VSTD::swap(__base::__map_.__end_, __buf.__end_);
+        _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
     }
 }
 
@@ -2405,7 +2405,7 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
     size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
     // Number of unused blocks at front:
     size_type __front_capacity = __front_spare() / __base::__block_size;
-    __front_capacity = _STD::min(__front_capacity, __nb);  // don't take more than you need
+    __front_capacity = _VSTD::min(__front_capacity, __nb);  // don't take more than you need
     __nb -= __front_capacity;  // number of blocks need to allocate
     // If __nb == 0, then we have sufficient capacity.
     if (__nb == 0)
@@ -2474,10 +2474,10 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
         for (typename __base::__map_pointer __i = __base::__map_.end();
                 __i != __base::__map_.begin();)
             __buf.push_front(*--__i);
-        _STD::swap(__base::__map_.__first_, __buf.__first_);
-        _STD::swap(__base::__map_.__begin_, __buf.__begin_);
-        _STD::swap(__base::__map_.__end_, __buf.__end_);
-        _STD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
+        _VSTD::swap(__base::__map_.__first_, __buf.__first_);
+        _VSTD::swap(__base::__map_.__begin_, __buf.__begin_);
+        _VSTD::swap(__base::__map_.__end_, __buf.__end_);
+        _VSTD::swap(__base::__map_.__end_cap(), __buf.__end_cap());
         __base::__start_ -= __ds;
     }
 }
@@ -2525,7 +2525,7 @@ deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __
 {
     // as if
     //   for (; __f != __l; ++__f, ++__r)
-    //       *__r = _STD::move(*__f);
+    //       *__r = _VSTD::move(*__f);
     difference_type __n = __l - __f;
     while (__n > 0)
     {
@@ -2539,7 +2539,7 @@ deque<_Tp, _Allocator>::__move_and_check(iterator __f, iterator __l, iterator __
         }
         if (__fb <= __vt && __vt < __fe)
             __vt = (const_iterator(__f.__m_iter_, __vt) -= __f - __r).__ptr_;
-        __r = _STD::move(__fb, __fe, __r);
+        __r = _VSTD::move(__fb, __fe, __r);
         __n -= __bs;
         __f += __bs;
     }
@@ -2555,7 +2555,7 @@ deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, it
 {
     // as if
     //   while (__f != __l)
-    //       *--__r = _STD::move(*--__l);
+    //       *--__r = _VSTD::move(*--__l);
     difference_type __n = __l - __f;
     while (__n > 0)
     {
@@ -2570,7 +2570,7 @@ deque<_Tp, _Allocator>::__move_backward_and_check(iterator __f, iterator __l, it
         }
         if (__lb <= __vt && __vt < __le)
             __vt = (const_iterator(__l.__m_iter_, __vt) += __r - __l - 1).__ptr_;
-        __r = _STD::move_backward(__lb, __le, __r);
+        __r = _VSTD::move_backward(__lb, __le, __r);
         __n -= __bs;
         __l -= __bs - 1;
     }
@@ -2587,7 +2587,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
     allocator_type& __a = __base::__alloc();
     // as if
     //   for (; __f != __l; ++__r, ++__f, ++__base::size())
-    //       __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__f));
+    //       __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__f));
     difference_type __n = __l - __f;
     while (__n > 0)
     {
@@ -2602,7 +2602,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
         if (__fb <= __vt && __vt < __fe)
             __vt = (const_iterator(__f.__m_iter_, __vt) += __r - __f).__ptr_;
         for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
-            __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__fb));
+            __alloc_traits::construct(__a, _VSTD::addressof(*__r), _VSTD::move(*__fb));
         __n -= __bs;
         __f += __bs;
     }
@@ -2619,7 +2619,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
     // as if
     //   for (iterator __j = __l; __j != __f;)
     //   {
-    //       __alloc_traitsconstruct(__a, _STD::addressof(*--__r), _STD::move(*--__j));
+    //       __alloc_traitsconstruct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__j));
     //       --__base::__start_;
     //       ++__base::size();
     //   }
@@ -2639,7 +2639,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
             __vt = (const_iterator(__l.__m_iter_, __vt) -= __l - __r + 1).__ptr_;
         while (__le != __lb)
         {
-            __alloc_traits::construct(__a, _STD::addressof(*--__r), _STD::move(*--__le));
+            __alloc_traits::construct(__a, _VSTD::addressof(*--__r), _VSTD::move(*--__le));
             --__base::__start_;
             ++__base::size();
         }
@@ -2659,8 +2659,8 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
     allocator_type& __a = __base::__alloc();
     if (__pos < (__base::size() - 1) / 2)
     {   // erase from front
-        _STD::move_backward(__b, __p, _STD::next(__p));
-        __alloc_traits::destroy(__a, _STD::addressof(*__b));
+        _VSTD::move_backward(__b, __p, _VSTD::next(__p));
+        __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
         --__base::size();
         ++__base::__start_;
         if (__front_spare() >= 2 * __base::__block_size)
@@ -2672,8 +2672,8 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
     }
     else
     {   // erase from back
-        iterator __i = _STD::move(_STD::next(__p), __base::end(), __p);
-        __alloc_traits::destroy(__a, _STD::addressof(*__i));
+        iterator __i = _VSTD::move(_VSTD::next(__p), __base::end(), __p);
+        __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
         --__base::size();
         if (__back_spare() >= 2 * __base::__block_size)
         {
@@ -2697,9 +2697,9 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
         allocator_type& __a = __base::__alloc();
         if (__pos < (__base::size() - __n) / 2)
         {   // erase from front
-            iterator __i = _STD::move_backward(__b, __p, __p + __n);
+            iterator __i = _VSTD::move_backward(__b, __p, __p + __n);
             for (; __b != __i; ++__b)
-                __alloc_traits::destroy(__a, _STD::addressof(*__b));
+                __alloc_traits::destroy(__a, _VSTD::addressof(*__b));
             __base::size() -= __n;
             __base::__start_ += __n;
             while (__front_spare() >= 2 * __base::__block_size)
@@ -2711,9 +2711,9 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
         }
         else
         {   // erase from back
-            iterator __i = _STD::move(__p + __n, __base::end(), __p);
+            iterator __i = _VSTD::move(__p + __n, __base::end(), __p);
             for (iterator __e = __base::end(); __i != __e; ++__i)
-                __alloc_traits::destroy(__a, _STD::addressof(*__i));
+                __alloc_traits::destroy(__a, _VSTD::addressof(*__i));
             __base::size() -= __n;
             while (__back_spare() >= 2 * __base::__block_size)
             {
@@ -2737,7 +2737,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
         iterator __b = __base::begin();
         difference_type __pos = __f - __b;
         for (iterator __p = __b + __pos; __p != __e; ++__p)
-            __alloc_traits::destroy(__a, _STD::addressof(*__p));
+            __alloc_traits::destroy(__a, _VSTD::addressof(*__p));
         __base::size() -= __n;
         while (__back_spare() >= 2 * __base::__block_size)
         {
@@ -2771,7 +2771,7 @@ bool
 operator==(const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
     const typename deque<_Tp, _Allocator>::size_type __sz = __x.size();
-    return __sz == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Tp, class _Allocator>
@@ -2787,7 +2787,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator< (const deque<_Tp, _Allocator>& __x, const deque<_Tp, _Allocator>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Allocator>

include/exception

@@ -199,7 +199,7 @@ throw_with_nested (_Tp& __t, typename enable_if<
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
+    throw __nested<typename remove_reference<_Tp>::type>(_VSTD::forward<_Tp>(__t));
 #endif
 }
 
@@ -218,7 +218,7 @@ throw_with_nested (_Tp& __t, typename enable_if<
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    throw _STD::forward<_Tp>(__t);
+    throw _VSTD::forward<_Tp>(__t);
 #endif
 }
 

include/ext/hash_map

@@ -341,9 +341,9 @@ public:
     void operator()(pointer __p)
     {
         if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
         if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
@@ -666,11 +666,11 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -963,9 +963,9 @@ operator==(const hash_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
     {
         _EqRng __xeq = __x.equal_range(__i->first);
         _EqRng __yeq = __y.equal_range(__i->first);
-        if (_STD::distance(__xeq.first, __xeq.second) !=
-            _STD::distance(__yeq.first, __yeq.second) ||
-                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_VSTD::distance(__xeq.first, __xeq.second) !=
+            _VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
             return false;
         __i = __xeq.second;
     }

include/ext/hash_set

@@ -627,9 +627,9 @@ operator==(const hash_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
     {
         _EqRng __xeq = __x.equal_range(*__i);
         _EqRng __yeq = __y.equal_range(*__i);
-        if (_STD::distance(__xeq.first, __xeq.second) !=
-            _STD::distance(__yeq.first, __yeq.second) ||
-                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_VSTD::distance(__xeq.first, __xeq.second) !=
+            _VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
             return false;
         __i = __xeq.second;
     }

include/forward_list

@@ -178,7 +178,7 @@ template <class T, class Allocator>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class, class> struct __forward_list_node;
+template <class _Tp, class _VoidPtr> struct __forward_list_node;
 
 template <class _NodePtr>
 struct __forward_begin_node
@@ -208,8 +208,8 @@ struct __forward_list_node
     value_type __value_;
 };
 
-template<class, class> class forward_list;
-template<class> class __forward_list_const_iterator;
+template<class _Tp, class _Alloc> class forward_list;
+template<class _NodeConstPtr> class __forward_list_const_iterator;
 
 template <class _NodePtr>
 class _LIBCPP_VISIBLE __forward_list_iterator
@@ -446,7 +446,7 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     void __move_assign_alloc(__forward_list_base& __x, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {__alloc() = _STD::move(__x.__alloc());}
+        {__alloc() = _VSTD::move(__x.__alloc());}
 
     _LIBCPP_INLINE_VISIBILITY
     static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
@@ -464,7 +464,7 @@ private:
                                                                       true_type)
         _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
 };
@@ -475,7 +475,7 @@ template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 __forward_list_base<_Tp, _Alloc>::__forward_list_base(__forward_list_base&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
-    : __before_begin_(_STD::move(__x.__before_begin_))
+    : __before_begin_(_VSTD::move(__x.__before_begin_))
 {
     __x.__before_begin()->__next_ = nullptr;
 }
@@ -509,7 +509,7 @@ __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
                    __is_nothrow_swappable<__node_allocator>::value)
 {
     __swap_alloc(__alloc(), __x.__alloc());
-    using _STD::swap;
+    using _VSTD::swap;
     swap(__before_begin()->__next_, __x.__before_begin()->__next_);
 }
 
@@ -521,7 +521,7 @@ __forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
     for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
     {
         __node_pointer __next = __p->__next_;
-        __node_traits::destroy(__a, _STD::addressof(__p->__value_));
+        __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
         __node_traits::deallocate(__a, __p, 1);
         __p = __next;
     }
@@ -577,7 +577,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     forward_list(forward_list&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<base>::value)
-        : base(_STD::move(__x)) {}
+        : base(_VSTD::move(__x)) {}
     forward_list(forward_list&& __x, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     forward_list(initializer_list<value_type> __il);
@@ -718,7 +718,7 @@ public:
     template <class _Compare>
         _LIBCPP_INLINE_VISIBILITY
         void merge(forward_list&& __x, _Compare __comp)
-        {merge(__x, _STD::move(__comp));}
+        {merge(__x, _VSTD::move(__comp));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     void merge(forward_list& __x) {merge(__x, __less<value_type>());}
@@ -766,7 +766,7 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
                                                              __p = __p->__next_)
         {
             __h.reset(__node_traits::allocate(__a, 1));
-            __node_traits::construct(__a, _STD::addressof(__h->__value_));
+            __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
             __h->__next_ = nullptr;
             __p->__next_ = __h.release();
         }
@@ -832,7 +832,7 @@ forward_list<_Tp, _Alloc>::forward_list(const forward_list& __x,
 template <class _Tp, class _Alloc>
 forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,
                                         const allocator_type& __a)
-    : base(_STD::move(__x), __a)
+    : base(_VSTD::move(__x), __a)
 {
     if (base::__alloc() != __x.__alloc())
     {
@@ -929,7 +929,7 @@ typename enable_if
 forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
 {
     iterator __i = before_begin();
-    iterator __j = _STD::next(__i);
+    iterator __j = _VSTD::next(__i);
     iterator __e = end();
     for (; __j != __e && __f != __l; ++__i, ++__j, ++__f)
         *__j = *__f;
@@ -944,7 +944,7 @@ void
 forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
 {
     iterator __i = before_begin();
-    iterator __j = _STD::next(__i);
+    iterator __j = _VSTD::next(__i);
     iterator __e = end();
     for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
         *__j = __v;
@@ -973,8 +973,8 @@ forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_),
-                                  _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__a, _VSTD::addressof(__h->__value_),
+                                  _VSTD::forward<_Args>(__args)...);
     __h->__next_ = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __h.release();
 }
@@ -988,7 +988,7 @@ forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
     __h->__next_ = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __h.release();
 }
@@ -1002,7 +1002,7 @@ forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
     __h->__next_ = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __h.release();
 }
@@ -1014,7 +1014,7 @@ forward_list<_Tp, _Alloc>::pop_front()
     __node_allocator& __a = base::__alloc();
     __node_pointer __p = base::__before_begin()->__next_;
     base::__before_begin()->__next_ = __p->__next_;
-    __node_traits::destroy(__a, _STD::addressof(__p->__value_));
+    __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
     __node_traits::deallocate(__a, __p, 1);
 }
 
@@ -1030,8 +1030,8 @@ forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_),
-                                  _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__a, _VSTD::addressof(__h->__value_),
+                                  _VSTD::forward<_Args>(__args)...);
     __h->__next_ = __r->__next_;
     __r->__next_ = __h.release();
     return iterator(__r->__next_);
@@ -1047,7 +1047,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
     __h->__next_ = __r->__next_;
     __r->__next_ = __h.release();
     return iterator(__r->__next_);
@@ -1063,7 +1063,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __
     __node_allocator& __a = base::__alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
     __h->__next_ = __r->__next_;
     __r->__next_ = __h.release();
     return iterator(__r->__next_);
@@ -1080,7 +1080,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
         __node_allocator& __a = base::__alloc();
         typedef __allocator_destructor<__node_allocator> _D;
         unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-        __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+        __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
         __node_pointer __first = __h.release();
         __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1090,7 +1090,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
             for (--__n; __n != 0; --__n, __last = __last->__next_)
             {
                 __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+                __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
                 __last->__next_ = __h.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1100,7 +1100,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
             while (__first != nullptr)
             {
                 __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
+                __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
                 __node_traits::deallocate(__a, __first, 1);
                 __first = __next;
             }
@@ -1130,7 +1130,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
         __node_allocator& __a = base::__alloc();
         typedef __allocator_destructor<__node_allocator> _D;
         unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-        __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
+        __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
         __node_pointer __first = __h.release();
         __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1140,7 +1140,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
             for (++__f; __f != __l; ++__f, __last = __last->__next_)
             {
                 __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
+                __node_traits::construct(__a, _VSTD::addressof(__h->__value_), *__f);
                 __last->__next_ = __h.release();
             }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1150,7 +1150,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
             while (__first != nullptr)
             {
                 __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
+                __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
                 __node_traits::deallocate(__a, __first, 1);
                 __first = __next;
             }
@@ -1172,7 +1172,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
     __node_pointer __n = __p->__next_;
     __p->__next_ = __n->__next_;
     __node_allocator& __a = base::__alloc();
-    __node_traits::destroy(__a, _STD::addressof(__n->__value_));
+    __node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
     __node_traits::deallocate(__a, __n, 1);
     return iterator(__p->__next_);
 }
@@ -1193,7 +1193,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
             do
             {
                 __p = __n->__next_;
-                __node_traits::destroy(__a, _STD::addressof(__n->__value_));
+                __node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
                 __node_traits::deallocate(__a, __n, 1);
                 __n = __p;
             } while (__n != __e);
@@ -1226,7 +1226,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
                                                          __ptr = __ptr->__next_)
             {
                 __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_));
+                __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
                 __h->__next_ = nullptr;
                 __ptr->__next_ = __h.release();
             }
@@ -1258,7 +1258,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
                                                          __ptr = __ptr->__next_)
             {
                 __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+                __node_traits::construct(__a, _VSTD::addressof(__h->__value_), __v);
                 __h->__next_ = nullptr;
                 __ptr->__next_ = __h.release();
             }
@@ -1293,7 +1293,7 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
                                         forward_list& __x,
                                         const_iterator __i)
 {
-    const_iterator __lm1 = _STD::next(__i);
+    const_iterator __lm1 = _VSTD::next(__i);
     if (__p != __i && __p != __lm1)
     {
         const_cast<__node_pointer>(__i.__ptr_)->__next_ =
@@ -1370,7 +1370,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
     {
         if (__i.__ptr_->__next_->__value_ == __v)
         {
-            iterator __j = _STD::next(__i, 2);
+            iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && *__j == __v; ++__j)
                 ;
             erase_after(__i, __j);
@@ -1393,7 +1393,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
     {
         if (__pred(__i.__ptr_->__next_->__value_))
         {
-            iterator __j = _STD::next(__i, 2);
+            iterator __j = _VSTD::next(__i, 2);
             for (; __j != __e && __pred(*__j); ++__j)
                 ;
             erase_after(__i, __j);
@@ -1413,7 +1413,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
-        iterator __j = _STD::next(__i);
+        iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ;
         if (__i.__ptr_->__next_ != __j.__ptr_)
@@ -1488,7 +1488,7 @@ void
 forward_list<_Tp, _Alloc>::sort(_Compare __comp)
 {
     base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_,
-                                       _STD::distance(begin(), end()), __comp);
+                                       _VSTD::distance(begin(), end()), __comp);
 }
 
 template <class _Tp, class _Alloc>
@@ -1514,7 +1514,7 @@ forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
     }
     difference_type __sz1 = __sz / 2;
     difference_type __sz2 = __sz - __sz1;
-    __node_pointer __t = _STD::next(iterator(__f1), __sz1 - 1).__ptr_;
+    __node_pointer __t = _VSTD::next(iterator(__f1), __sz1 - 1).__ptr_;
     __node_pointer __f2 = __t->__next_;
     __t->__next_ = nullptr;
     return __merge(__sort(__f1, __sz1, __comp),
@@ -1570,7 +1570,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool operator< (const forward_list<_Tp, _Alloc>& __x,
                 const forward_list<_Tp, _Alloc>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(),
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
                                          __y.begin(), __y.end());
 }
 

include/fstream

@@ -362,9 +362,9 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
     basic_streambuf<char_type, traits_type>::swap(__rhs);
     if (__extbuf_ != __extbuf_min_ && __rhs.__extbuf_ != __rhs.__extbuf_min_)
     {
-        _STD::swap(__extbuf_, __rhs.__extbuf_);
-        _STD::swap(__extbufnext_, __rhs.__extbufnext_);
-        _STD::swap(__extbufend_, __rhs.__extbufend_);
+        _VSTD::swap(__extbuf_, __rhs.__extbuf_);
+        _VSTD::swap(__extbufnext_, __rhs.__extbufnext_);
+        _VSTD::swap(__extbufend_, __rhs.__extbufend_);
     }
     else
     {
@@ -387,17 +387,17 @@ basic_filebuf<_CharT, _Traits>::swap(basic_filebuf& __rhs)
         __rhs.__extbufnext_ = __rhs.__extbuf_ + __ln;
         __rhs.__extbufend_ = __rhs.__extbuf_ + __le;
     }
-    _STD::swap(__ebs_, __rhs.__ebs_);
-    _STD::swap(__intbuf_, __rhs.__intbuf_);
-    _STD::swap(__ibs_, __rhs.__ibs_);
-    _STD::swap(__file_, __rhs.__file_);
-    _STD::swap(__cv_, __rhs.__cv_);
-    _STD::swap(__st_, __rhs.__st_);
-    _STD::swap(__om_, __rhs.__om_);
-    _STD::swap(__cm_, __rhs.__cm_);
-    _STD::swap(__owns_eb_, __rhs.__owns_eb_);
-    _STD::swap(__owns_ib_, __rhs.__owns_ib_);
-    _STD::swap(__always_noconv_, __rhs.__always_noconv_);
+    _VSTD::swap(__ebs_, __rhs.__ebs_);
+    _VSTD::swap(__intbuf_, __rhs.__intbuf_);
+    _VSTD::swap(__ibs_, __rhs.__ibs_);
+    _VSTD::swap(__file_, __rhs.__file_);
+    _VSTD::swap(__cv_, __rhs.__cv_);
+    _VSTD::swap(__st_, __rhs.__st_);
+    _VSTD::swap(__om_, __rhs.__om_);
+    _VSTD::swap(__cm_, __rhs.__cm_);
+    _VSTD::swap(__owns_eb_, __rhs.__owns_eb_);
+    _VSTD::swap(__owns_ib_, __rhs.__owns_ib_);
+    _VSTD::swap(__always_noconv_, __rhs.__always_noconv_);
     if (this->eback() == (char_type*)__rhs.__extbuf_min_)
     {
         ptrdiff_t __n = this->gptr() - this->eback();
@@ -587,7 +587,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
             memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
             __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
             __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            size_t __nmemb = _STD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
+            size_t __nmemb = _VSTD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
                                  static_cast<size_t>(__extbufend_ - __extbufnext_));
             codecvt_base::result __r;
             state_type __svs = __st_;
@@ -1019,8 +1019,8 @@ basic_ifstream<_CharT, _Traits>::basic_ifstream(const string& __s, ios_base::ope
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ifstream<_CharT, _Traits>::basic_ifstream(basic_ifstream&& __rhs)
-    : basic_istream<char_type, traits_type>(_STD::move(__rhs)),
-      __sb_(_STD::move(__rhs.__sb_))
+    : basic_istream<char_type, traits_type>(_VSTD::move(__rhs)),
+      __sb_(_VSTD::move(__rhs.__sb_))
 {
     this->set_rdbuf(&__sb_);
 }
@@ -1030,8 +1030,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 basic_ifstream<_CharT, _Traits>&
 basic_ifstream<_CharT, _Traits>::operator=(basic_ifstream&& __rhs)
 {
-    basic_istream<char_type, traits_type>::operator=(_STD::move(__rhs));
-    __sb_ = _STD::move(__rhs.__sb_);
+    basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
+    __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
@@ -1164,8 +1164,8 @@ basic_ofstream<_CharT, _Traits>::basic_ofstream(const string& __s, ios_base::ope
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ofstream<_CharT, _Traits>::basic_ofstream(basic_ofstream&& __rhs)
-    : basic_ostream<char_type, traits_type>(_STD::move(__rhs)),
-      __sb_(_STD::move(__rhs.__sb_))
+    : basic_ostream<char_type, traits_type>(_VSTD::move(__rhs)),
+      __sb_(_VSTD::move(__rhs.__sb_))
 {
     this->set_rdbuf(&__sb_);
 }
@@ -1175,8 +1175,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 basic_ofstream<_CharT, _Traits>&
 basic_ofstream<_CharT, _Traits>::operator=(basic_ofstream&& __rhs)
 {
-    basic_ostream<char_type, traits_type>::operator=(_STD::move(__rhs));
-    __sb_ = _STD::move(__rhs.__sb_);
+    basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
+    __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
@@ -1309,8 +1309,8 @@ basic_fstream<_CharT, _Traits>::basic_fstream(const string& __s, ios_base::openm
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_fstream<_CharT, _Traits>::basic_fstream(basic_fstream&& __rhs)
-    : basic_iostream<char_type, traits_type>(_STD::move(__rhs)),
-      __sb_(_STD::move(__rhs.__sb_))
+    : basic_iostream<char_type, traits_type>(_VSTD::move(__rhs)),
+      __sb_(_VSTD::move(__rhs.__sb_))
 {
     this->set_rdbuf(&__sb_);
 }
@@ -1320,8 +1320,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 basic_fstream<_CharT, _Traits>&
 basic_fstream<_CharT, _Traits>::operator=(basic_fstream&& __rhs)
 {
-    basic_iostream<char_type, traits_type>::operator=(_STD::move(__rhs));
-    __sb_ = _STD::move(__rhs.__sb_);
+    basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
+    __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 

include/functional

@@ -884,7 +884,7 @@ public:
        typename __invoke_return<type, _ArgTypes...>::type
           operator() (_ArgTypes&&... __args)
           {
-              return __invoke(__f_, _STD::forward<_ArgTypes>(__args)...);
+              return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
           }
 };
 
@@ -992,9 +992,9 @@ class __func<_F, _Alloc, _R(_ArgTypes...)>
     __compressed_pair<_F, _Alloc> __f_;
 public:
     _LIBCPP_INLINE_VISIBILITY
-    explicit __func(_F __f) : __f_(_STD::move(__f)) {}
+    explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::move(__a)) {}
+    explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
     virtual __base<_R(_ArgTypes...)>* __clone() const;
     virtual void __clone(__base<_R(_ArgTypes...)>*) const;
     virtual void destroy() _NOEXCEPT;
@@ -1046,7 +1046,7 @@ template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 _R
 __func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
-    return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
+    return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 #ifndef _LIBCPP_NO_RTTI
@@ -1162,7 +1162,7 @@ public:
     template<class _F, class _Alloc>
       _LIBCPP_INLINE_VISIBILITY
       void assign(_F&& __f, const _Alloc& __a)
-        {function(allocator_arg, __a, _STD::forward<_F>(__f)).swap(*this);}
+        {function(allocator_arg, __a, _VSTD::forward<_F>(__f)).swap(*this);}
 
     // function capacity:
     _LIBCPP_INLINE_VISIBILITY
@@ -1263,7 +1263,7 @@ function<_R(_ArgTypes...)>::function(_F __f,
         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
         {
             __f_ = (__base*)&__buf_;
-            ::new (__f_) _FF(_STD::move(__f));
+            ::new (__f_) _FF(_VSTD::move(__f));
         }
         else
         {
@@ -1271,7 +1271,7 @@ function<_R(_ArgTypes...)>::function(_F __f,
             _A __a;
             typedef __allocator_destructor<_A> _D;
             unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
-            ::new (__hold.get()) _FF(_STD::move(__f), allocator<_F>(__a));
+            ::new (__hold.get()) _FF(_VSTD::move(__f), allocator<_F>(__a));
             __f_ = __hold.release();
         }
     }
@@ -1290,7 +1290,7 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f
         if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
         {
             __f_ = (__base*)&__buf_;
-            ::new (__f_) _FF(_STD::move(__f));
+            ::new (__f_) _FF(_VSTD::move(__f));
         }
         else
         {
@@ -1304,7 +1304,7 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f
             _A __a(__a0);
             typedef __allocator_destructor<_A> _D;
             unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
-            ::new (__hold.get()) _FF(_STD::move(__f), _Alloc(__a));
+            ::new (__hold.get()) _FF(_VSTD::move(__f), _Alloc(__a));
             __f_ = __hold.release();
         }
     }
@@ -1361,7 +1361,7 @@ typename enable_if
 >::type
 function<_R(_ArgTypes...)>::operator=(_F&& __f)
 {
-    function(_STD::forward<_F>(__f)).swap(*this);
+    function(_VSTD::forward<_F>(__f)).swap(*this);
     return *this;
 }
 
@@ -1408,7 +1408,7 @@ function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
         __f_ = (__base*)&__buf_;
     }
     else
-        _STD::swap(__f_, __f.__f_);
+        _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _R, class ..._ArgTypes>
@@ -1419,7 +1419,7 @@ function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
     if (__f_ == 0)
         throw bad_function_call();
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
+    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 #ifndef _LIBCPP_NO_RTTI
@@ -1524,7 +1524,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename __invoke_of<_Ti&, _Uj...>::type
 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
 {
-    return __ti(_STD::forward<_Uj>(get<_Indx>(__uj))...);
+    return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
 }
 
 template <class _Ti, class ..._Uj>
@@ -1559,7 +1559,7 @@ typename enable_if
 __mu(_Ti&, _Uj& __uj)
 {
     const size_t _Indx = is_placeholder<_Ti>::value - 1;
-    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+    return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
 }
 
 template <class _Ti, class _Uj>
@@ -1666,16 +1666,41 @@ class __bind
 
     typedef typename __make_tuple_indices<sizeof...(_BoundArgs)>::type __indices;
 public:
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __bind(const __bind& __b)
+        : __f_(__b.__f_),
+          __bound_args_(__b.__bound_args_) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __bind& operator=(const __bind& __b)
+    {
+        __f_ = __b.__f_;
+        __bound_args_ = __b.__bound_args_;
+        return *this;
+    }
+
     _LIBCPP_INLINE_VISIBILITY
     __bind(__bind&& __b)
-        : __f_(_STD::move(__b.__f_)),
-          __bound_args_(_STD::move(__b.__bound_args_)) {}
+        : __f_(_VSTD::move(__b.__f_)),
+          __bound_args_(_VSTD::move(__b.__bound_args_)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __bind& operator=(__bind&& __b)
+    {
+        __f_ = _VSTD::move(__b.__f_);
+        __bound_args_ = _VSTD::move(__b.__bound_args_);
+        return *this;
+    }
+
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
     template <class _G, class ..._BA>
       _LIBCPP_INLINE_VISIBILITY
       explicit __bind(_G&& __f, _BA&& ...__bound_args)
-        : __f_(_STD::forward<_G>(__f)),
-          __bound_args_(_STD::forward<_BA>(__bound_args)...) {}
+        : __f_(_VSTD::forward<_G>(__f)),
+          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
@@ -1683,7 +1708,7 @@ public:
         operator()(_Args&& ...__args)
         {
             return __apply_functor(__f_, __bound_args_, __indices(),
-                                  tuple<_Args&&...>(_STD::forward<_Args>(__args)...));
+                                  tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
         }
 
     template <class ..._Args>
@@ -1692,7 +1717,7 @@ public:
         operator()(_Args&& ...__args) const
         {
             return __apply_functor(__f_, __bound_args_, __indices(),
-                                   tuple<_Args&&...>(_STD::forward<_Args>(__args)...));
+                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
         }
 };
 
@@ -1707,22 +1732,44 @@ class __bind_r
 public:
     typedef _R result_type;
 
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __bind_r(const __bind_r& __b)
+        : base(_VSTD::forward<const base&>(__b)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __bind_r& operator=(const __bind_r& __b)
+    {
+        base::operator=(_VSTD::forward<const base&>(__b));
+        return *this;
+    }
+
     _LIBCPP_INLINE_VISIBILITY
     __bind_r(__bind_r&& __b)
-        : base(_STD::forward<base>(__b)) {}
+        : base(_VSTD::forward<base>(__b)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __bind_r& operator=(__bind_r&& __b)
+    {
+        base::operator=(_VSTD::forward<base>(__b));
+        return *this;
+    }
+
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
 
     template <class _G, class ..._BA>
       _LIBCPP_INLINE_VISIBILITY
       explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
-        : base(_STD::forward<_G>(__f),
-               _STD::forward<_BA>(__bound_args)...) {}
+        : base(_VSTD::forward<_G>(__f),
+               _VSTD::forward<_BA>(__bound_args)...) {}
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         result_type
         operator()(_Args&& ...__args)
         {
-            return base::operator()(_STD::forward<_Args>(__args)...);
+            return base::operator()(_VSTD::forward<_Args>(__args)...);
         }
 
     template <class ..._Args>
@@ -1730,7 +1777,7 @@ public:
         result_type
         operator()(_Args&& ...__args) const
         {
-            return base::operator()(_STD::forward<_Args>(__args)...);
+            return base::operator()(_VSTD::forward<_Args>(__args)...);
         }
 };
 
@@ -1743,7 +1790,7 @@ __bind<_F, _BoundArgs...>
 bind(_F&& __f, _BoundArgs&&... __bound_args)
 {
     typedef __bind<_F, _BoundArgs...> type;
-    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
+    return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 }
 
 template<class _R, class _F, class ..._BoundArgs>
@@ -1752,7 +1799,7 @@ __bind_r<_R, _F, _BoundArgs...>
 bind(_F&& __f, _BoundArgs&&... __bound_args)
 {
     typedef __bind_r<_R, _F, _BoundArgs...> type;
-    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
+    return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS

include/future

@@ -452,6 +452,8 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     const error_code& code() const throw() {return __ec_;}
+
+    virtual ~future_error() _NOEXCEPT;
 };
 
 class __assoc_sub_state
@@ -583,9 +585,11 @@ __assoc_state<_R>::set_value(_Arg& __arg)
 #endif
 {
     unique_lock<mutex> __lk(this->__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
-    ::new(&__value_) _R(_STD::forward<_Arg>(__arg));
+#endif
+    ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
     this->__state_ |= base::__constructed | base::ready;
     __lk.unlock();
     __cv_.notify_all();
@@ -601,9 +605,11 @@ __assoc_state<_R>::set_value_at_thread_exit(_Arg& __arg)
 #endif
 {
     unique_lock<mutex> __lk(this->__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
-    ::new(&__value_) _R(_STD::forward<_Arg>(__arg));
+#endif
+    ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
     this->__state_ |= base::__constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
     __lk.unlock();
@@ -617,7 +623,7 @@ __assoc_state<_R>::move()
     this->__sub_wait(__lk);
     if (this->__exception_ != nullptr)
         rethrow_exception(this->__exception_);
-    return _STD::move(*reinterpret_cast<_R*>(&__value_));
+    return _VSTD::move(*reinterpret_cast<_R*>(&__value_));
 }
 
 template <class _R>
@@ -661,8 +667,10 @@ void
 __assoc_state<_R&>::set_value(_R& __arg)
 {
     unique_lock<mutex> __lk(this->__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
+#endif
     __value_ = &__arg;
     this->__state_ |= base::__constructed | base::ready;
     __lk.unlock();
@@ -674,8 +682,10 @@ void
 __assoc_state<_R&>::set_value_at_thread_exit(_R& __arg)
 {
     unique_lock<mutex> __lk(this->__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (this->__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
+#endif
     __value_ = &__arg;
     this->__state_ |= base::__constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
@@ -786,7 +796,7 @@ public:
 template <class _R, class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f)
-    : __func_(_STD::forward<_F>(__f))
+    : __func_(_VSTD::forward<_F>(__f))
 {
     this->__set_deferred();
 }
@@ -832,7 +842,7 @@ public:
 template <class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f)
-    : __func_(_STD::forward<_F>(__f))
+    : __func_(_VSTD::forward<_F>(__f))
 {
     this->__set_deferred();
 }
@@ -880,7 +890,7 @@ public:
 template <class _R, class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f)
-    : __func_(_STD::forward<_F>(__f))
+    : __func_(_VSTD::forward<_F>(__f))
 {
 }
 
@@ -934,7 +944,7 @@ public:
 template <class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __async_assoc_state<void, _F>::__async_assoc_state(_F&& __f)
-    : __func_(_STD::forward<_F>(__f))
+    : __func_(_VSTD::forward<_F>(__f))
 {
 }
 
@@ -967,9 +977,8 @@ __async_assoc_state<void, _F>::__on_zero_shared() _NOEXCEPT
     base::__on_zero_shared();
 }
 
-template <class> class promise;
-template <class> class shared_future;
-template <class> class atomic_future;
+template <class _R> class promise;
+template <class _R> class shared_future;
 
 // future
 
@@ -1000,7 +1009,6 @@ class _LIBCPP_VISIBLE future
 
     template <class> friend class promise;
     template <class> friend class shared_future;
-    template <class> friend class atomic_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _R1, class _F>
@@ -1042,7 +1050,7 @@ public:
     _R get();
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
@@ -1066,8 +1074,10 @@ template <class _R>
 future<_R>::future(__assoc_state<_R>* __state)
     : __state_(__state)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_->__has_future_attached())
         throw future_error(make_error_code(future_errc::future_already_retrieved));
+#endif
     __state_->__add_shared();
     __state_->__set_future_attached();
 }
@@ -1103,7 +1113,6 @@ class _LIBCPP_VISIBLE future<_R&>
 
     template <class> friend class promise;
     template <class> friend class shared_future;
-    template <class> friend class atomic_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _R1, class _F>
@@ -1145,7 +1154,7 @@ public:
     _R& get();
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
@@ -1169,8 +1178,10 @@ template <class _R>
 future<_R&>::future(__assoc_state<_R&>* __state)
     : __state_(__state)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_->__has_future_attached())
         throw future_error(make_error_code(future_errc::future_already_retrieved));
+#endif
     __state_->__add_shared();
     __state_->__set_future_attached();
 }
@@ -1201,7 +1212,6 @@ class _LIBCPP_VISIBLE future<void>
 
     template <class> friend class promise;
     template <class> friend class shared_future;
-    template <class> friend class atomic_future;
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _R1, class _F>
@@ -1243,7 +1253,7 @@ public:
     void get();
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
@@ -1273,7 +1283,7 @@ swap(future<_R>& __x, future<_R>& __y)
 
 // promise<R>
 
-template <class> class packaged_task;
+template <class _Callable> class packaged_task;
 
 template <class _R>
 class _LIBCPP_VISIBLE promise
@@ -1315,7 +1325,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<_R> get_future();
@@ -1370,8 +1380,10 @@ template <class _R>
 future<_R>
 promise<_R>::get_future()
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     return future<_R>(__state_);
 }
 
@@ -1379,8 +1391,10 @@ template <class _R>
 void
 promise<_R>::set_value(const _R& __r)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_value(__r);
 }
 
@@ -1390,9 +1404,11 @@ template <class _R>
 void
 promise<_R>::set_value(_R&& __r)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
-    __state_->set_value(_STD::move(__r));
+#endif
+    __state_->set_value(_VSTD::move(__r));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1401,8 +1417,10 @@ template <class _R>
 void
 promise<_R>::set_exception(exception_ptr __p)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_exception(__p);
 }
 
@@ -1410,8 +1428,10 @@ template <class _R>
 void
 promise<_R>::set_value_at_thread_exit(const _R& __r)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_value_at_thread_exit(__r);
 }
 
@@ -1421,9 +1441,11 @@ template <class _R>
 void
 promise<_R>::set_value_at_thread_exit(_R&& __r)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
-    __state_->set_value_at_thread_exit(_STD::move(__r));
+#endif
+    __state_->set_value_at_thread_exit(_VSTD::move(__r));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1432,8 +1454,10 @@ template <class _R>
 void
 promise<_R>::set_exception_at_thread_exit(exception_ptr __p)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_exception_at_thread_exit(__p);
 }
 
@@ -1480,7 +1504,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<_R&> get_future();
@@ -1529,8 +1553,10 @@ template <class _R>
 future<_R&>
 promise<_R&>::get_future()
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     return future<_R&>(__state_);
 }
 
@@ -1538,8 +1564,10 @@ template <class _R>
 void
 promise<_R&>::set_value(_R& __r)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_value(__r);
 }
 
@@ -1547,8 +1575,10 @@ template <class _R>
 void
 promise<_R&>::set_exception(exception_ptr __p)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_exception(__p);
 }
 
@@ -1556,8 +1586,10 @@ template <class _R>
 void
 promise<_R&>::set_value_at_thread_exit(_R& __r)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_value_at_thread_exit(__r);
 }
 
@@ -1565,8 +1597,10 @@ template <class _R>
 void
 promise<_R&>::set_exception_at_thread_exit(exception_ptr __p)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_exception_at_thread_exit(__p);
 }
 
@@ -1613,7 +1647,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // retrieving the result
     future<void> get_future();
@@ -1683,13 +1717,13 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     explicit __packaged_task_func(const _F& __f) : __f_(__f) {}
     _LIBCPP_INLINE_VISIBILITY
-    explicit __packaged_task_func(_F&& __f) : __f_(_STD::move(__f)) {}
+    explicit __packaged_task_func(_F&& __f) : __f_(_VSTD::move(__f)) {}
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_func(const _F& __f, const _Alloc& __a)
         : __f_(__f, __a) {}
     _LIBCPP_INLINE_VISIBILITY
     __packaged_task_func(_F&& __f, const _Alloc& __a)
-        : __f_(_STD::move(__f), __a) {}
+        : __f_(_VSTD::move(__f), __a) {}
     virtual void __move_to(__packaged_task_base<_R(_ArgTypes...)>*);
     virtual void destroy();
     virtual void destroy_deallocate();
@@ -1701,7 +1735,7 @@ void
 __packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::__move_to(
                               __packaged_task_base<_R(_ArgTypes...)>* __p)
 {
-    ::new (__p) __packaged_task_func(_STD::move(__f_.first()), _STD::move(__f_.second()));
+    ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
 }
 
 template<class _F, class _Alloc, class _R, class ..._ArgTypes>
@@ -1725,10 +1759,10 @@ template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 _R
 __packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
-    return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
+    return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
 }
 
-template <class> class __packaged_task_function;
+template <class _Callable> class __packaged_task_function;
 
 template<class _R, class ..._ArgTypes>
 class __packaged_task_function<_R(_ArgTypes...)>
@@ -1788,7 +1822,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
     if (sizeof(_FF) <= sizeof(__buf_))
     {
         __f_ = (__base*)&__buf_;
-        ::new (__f_) _FF(_STD::forward<_F>(__f));
+        ::new (__f_) _FF(_VSTD::forward<_F>(__f));
     }
     else
     {
@@ -1796,7 +1830,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
         _A __a;
         typedef __allocator_destructor<_A> _D;
         unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
-        ::new (__hold.get()) _FF(_STD::forward<_F>(__f), allocator<_FR>(__a));
+        ::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), allocator<_FR>(__a));
         __f_ = __hold.release();
     }
 }
@@ -1813,7 +1847,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
     if (sizeof(_FF) <= sizeof(__buf_))
     {
         __f_ = (__base*)&__buf_;
-        ::new (__f_) _FF(_STD::forward<_F>(__f));
+        ::new (__f_) _FF(_VSTD::forward<_F>(__f));
     }
     else
     {
@@ -1827,7 +1861,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
         _A __a(__a0);
         typedef __allocator_destructor<_A> _D;
         unique_ptr<__base, _D> __hold(__a.allocate(1), _D(__a, 1));
-        ::new (__hold.get()) _FF(_STD::forward<_F>(__f), _Alloc(__a));
+        ::new (__hold.get()) _FF(_VSTD::forward<_F>(__f), _Alloc(__a));
         __f_ = __hold.release();
     }
 }
@@ -1898,7 +1932,7 @@ __packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f)
         __f_ = (__base*)&__buf_;
     }
     else
-        _STD::swap(__f_, __f.__f_);
+        _VSTD::swap(__f_, __f.__f_);
 }
 
 template<class _R, class ..._ArgTypes>
@@ -1906,7 +1940,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _R
 __packaged_task_function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 {
-    return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
+    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
 }
 
 template<class _R, class ..._ArgTypes>
@@ -1925,11 +1959,11 @@ public:
     packaged_task() : __p_(nullptr) {}
     template <class _F>
         _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_F&& __f) : __f_(_STD::forward<_F>(__f)) {}
+        explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
     template <class _F, class _Allocator>
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
-             : __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
+             : __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)),
                __p_(allocator_arg, __a) {}
     // ~packaged_task() = default;
 
@@ -1940,12 +1974,12 @@ public:
     // move support
     _LIBCPP_INLINE_VISIBILITY
     packaged_task(packaged_task&& __other)
-        : __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
+        : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
     _LIBCPP_INLINE_VISIBILITY
     packaged_task& operator=(packaged_task&& __other)
     {
-        __f_ = _STD::move(__other.__f_);
-        __p_ = _STD::move(__other.__p_);
+        __f_ = _VSTD::move(__other.__f_);
+        __p_ = _VSTD::move(__other.__p_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
@@ -1981,7 +2015,7 @@ packaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args)
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __p_.set_value(__f_(_STD::forward<_ArgTypes>(__args)...));
+        __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
@@ -2003,7 +2037,7 @@ packaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __p_.set_value_at_thread_exit(__f_(_STD::forward<_ArgTypes>(__args)...));
+        __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
     catch (...)
@@ -2040,11 +2074,11 @@ public:
     packaged_task() : __p_(nullptr) {}
     template <class _F>
         _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_F&& __f) : __f_(_STD::forward<_F>(__f)) {}
+        explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
     template <class _F, class _Allocator>
         _LIBCPP_INLINE_VISIBILITY
         explicit packaged_task(allocator_arg_t, const _Allocator& __a, _F&& __f)
-             : __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
+             : __f_(allocator_arg, __a, _VSTD::forward<_F>(__f)),
                __p_(allocator_arg, __a) {}
     // ~packaged_task() = default;
 
@@ -2055,12 +2089,12 @@ public:
     // move support
     _LIBCPP_INLINE_VISIBILITY
     packaged_task(packaged_task&& __other)
-        : __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
+        : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
     _LIBCPP_INLINE_VISIBILITY
     packaged_task& operator=(packaged_task&& __other)
     {
-        __f_ = _STD::move(__other.__f_);
-        __p_ = _STD::move(__other.__p_);
+        __f_ = _VSTD::move(__other.__f_);
+        __p_ = _VSTD::move(__other.__p_);
         return *this;
     }
     _LIBCPP_INLINE_VISIBILITY
@@ -2096,7 +2130,7 @@ packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __f_(_STD::forward<_ArgTypes>(__args)...);
+        __f_(_VSTD::forward<_ArgTypes>(__args)...);
         __p_.set_value();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
@@ -2119,7 +2153,7 @@ packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args
     try
     {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __f_(_STD::forward<_ArgTypes>(__args)...);
+        __f_(_VSTD::forward<_ArgTypes>(__args)...);
         __p_.set_value_at_thread_exit();
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
@@ -2162,7 +2196,7 @@ __make_deferred_assoc_state(_F __f)
 #endif
 {
     unique_ptr<__deferred_assoc_state<_R, _F>, __release_shared_count>
-        __h(new __deferred_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
+        __h(new __deferred_assoc_state<_R, _F>(_VSTD::forward<_F>(__f)));
     return future<_R>(__h.get());
 }
 
@@ -2175,8 +2209,8 @@ __make_async_assoc_state(_F __f)
 #endif
 {
     unique_ptr<__async_assoc_state<_R, _F>, __release_shared_count>
-        __h(new __async_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
-    _STD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
+        __h(new __async_assoc_state<_R, _F>(_VSTD::forward<_F>(__f)));
+    _VSTD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
     return future<_R>(__h.get());
 }
 
@@ -2190,10 +2224,10 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __async_func(_F&& __f, _Args&&... __args)
-        : __f_(_STD::move(__f), _STD::move(__args)...) {}
+        : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
 
     _LIBCPP_INLINE_VISIBILITY
-    __async_func(__async_func&& __f) : __f_(_STD::move(__f.__f_)) {}
+    __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
 
     _R operator()()
     {
@@ -2205,7 +2239,7 @@ private:
     _R
     __execute(__tuple_indices<_Indices...>)
     {
-        return __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...);
+        return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
     }
 };
 
@@ -2217,11 +2251,11 @@ async(launch __policy, _F&& __f, _Args&&... __args)
     typedef typename _BF::_R _R;
     future<_R> __r;
     if (__policy & launch::async)
-        __r = _STD::__make_async_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)),
-                                                     __decay_copy(_STD::forward<_Args>(__args))...));
+        __r = _VSTD::__make_async_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
+                                                     __decay_copy(_VSTD::forward<_Args>(__args))...));
     else if (__policy & launch::deferred)
-        __r = _STD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)),
-                                                        __decay_copy(_STD::forward<_Args>(__args))...));
+        __r = _VSTD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
+                                                        __decay_copy(_VSTD::forward<_Args>(__args))...));
     return __r;
 }
 
@@ -2230,8 +2264,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type>
 async(_F&& __f, _Args&&... __args)
 {
-    return _STD::async(launch::any, _STD::forward<_F>(__f),
-                                    _STD::forward<_Args>(__args)...);
+    return _VSTD::async(launch::any, _VSTD::forward<_F>(__f),
+                                    _VSTD::forward<_Args>(__args)...);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -2273,7 +2307,7 @@ public:
     const _R& get() const {return __state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
@@ -2347,7 +2381,7 @@ public:
     _R& get() const {return __state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
@@ -2421,7 +2455,7 @@ public:
     void get() const {__state_->copy();}
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
 
     // functions to check state
     _LIBCPP_INLINE_VISIBILITY
@@ -2454,7 +2488,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_future<_R>
 future<_R>::share()
 {
-    return shared_future<_R>(_STD::move(*this));
+    return shared_future<_R>(_VSTD::move(*this));
 }
 
 template <class _R>
@@ -2462,7 +2496,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_future<_R&>
 future<_R&>::share()
 {
-    return shared_future<_R&>(_STD::move(*this));
+    return shared_future<_R&>(_VSTD::move(*this));
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2471,7 +2505,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_future<void>
 future<void>::share()
 {
-    return shared_future<void>(_STD::move(*this));
+    return shared_future<void>(_VSTD::move(*this));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

include/ios

@@ -266,8 +266,8 @@ public:
     enum seekdir {beg, cur, end};
     typedef seekdir seek_dir;
 
-    typedef _STD::streamoff streamoff;
-    typedef _STD::streampos streampos;
+    typedef _VSTD::streamoff streamoff;
+    typedef _VSTD::streampos streampos;
 
     class Init;
 
@@ -776,8 +776,8 @@ void
 basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs)
 {
     ios_base::swap(__rhs);
-    _STD::swap(__tie_, __rhs.__tie_);
-    _STD::swap(__fill_, __rhs.__fill_);
+    _VSTD::swap(__tie_, __rhs.__tie_);
+    _VSTD::swap(__fill_, __rhs.__fill_);
 }
 
 template <class _CharT, class _Traits>

include/istream

@@ -177,11 +177,13 @@ public:
     virtual ~basic_istream();
 protected:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_istream(basic_istream&& __rhs);
 #endif
 
     // 27.7.1.1.2 Assign/swap:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_istream& operator=(basic_istream&& __rhs);
 #endif
     void swap(basic_istream& __rhs);
@@ -321,7 +323,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_istream<_CharT, _Traits>::swap(basic_istream& __rhs)
 {
-    _STD::swap(__gc_, __rhs.__gc_);
+    _VSTD::swap(__gc_, __rhs.__gc_);
     basic_ios<char_type, traits_type>::swap(__rhs);
 }
 
@@ -1273,7 +1275,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
             case 0:
                 break;
             default:
-                __c = _STD::min(__c, __n);
+                __c = _VSTD::min(__c, __n);
                 for (streamsize __k = 0; __k < __c; ++__k, ++__s, ++__i)
                     *__s = *__i;
             }
@@ -1504,11 +1506,13 @@ public:
     virtual ~basic_iostream();
 protected:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_iostream(basic_iostream&& __rhs);
 #endif
 
     // assign/swap
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_iostream& operator=(basic_iostream&& __rhs);
 #endif
     void swap(basic_iostream& __rhs);
@@ -1527,7 +1531,7 @@ basic_iostream<_CharT, _Traits>::basic_iostream(basic_streambuf<char_type, trait
 template <class _CharT, class _Traits>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_iostream<_CharT, _Traits>::basic_iostream(basic_iostream&& __rhs)
-    : basic_istream<_CharT, _Traits>(_STD::move(__rhs))
+    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs))
 {
 }
 

include/iterator

@@ -488,7 +488,7 @@ next(_ForwardIter __x,
      typename iterator_traits<_ForwardIter>::difference_type __n = 1,
      typename enable_if<__is_forward_iterator<_ForwardIter>::value>::type* = 0)
 {
-    _STD::advance(__x, __n);
+    _VSTD::advance(__x, __n);
     return __x;
 }
 
@@ -499,7 +499,7 @@ prev(_BidiretionalIter __x,
      typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
      typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
 {
-    _STD::advance(__x, -__n);
+    _VSTD::advance(__x, -__n);
     return __x;
 }
 
@@ -628,7 +628,7 @@ public:
         {container->push_back(__value); return *this;}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator=(typename _Container::value_type&& __value)
-        {container->push_back(_STD::move(__value)); return *this;}
+        {container->push_back(_VSTD::move(__value)); return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY back_insert_iterator& operator++()    {return *this;}
@@ -661,7 +661,7 @@ public:
         {container->push_front(__value); return *this;}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator=(typename _Container::value_type&& __value)
-        {container->push_front(_STD::move(__value)); return *this;}
+        {container->push_front(_VSTD::move(__value)); return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator*()     {return *this;}
     _LIBCPP_INLINE_VISIBILITY front_insert_iterator& operator++()    {return *this;}
@@ -696,7 +696,7 @@ public:
         {iter = container->insert(iter, __value); ++iter; return *this;}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator=(typename _Container::value_type&& __value)
-        {iter = container->insert(iter, _STD::move(__value)); ++iter; return *this;}
+        {iter = container->insert(iter, _VSTD::move(__value)); ++iter; return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator*()        {return *this;}
     _LIBCPP_INLINE_VISIBILITY insert_iterator& operator++()       {return *this;}

include/list

@@ -180,7 +180,7 @@ template <class T, class Alloc>
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
-template <class, class> struct __list_node;
+template <class _Tp, class _VoidPtr> struct __list_node;
 
 template <class _Tp, class _VoidPtr>
 struct __list_node_base
@@ -209,9 +209,9 @@ struct __list_node
     _Tp __value_;
 };
 
-template <class, class> class list;
-template <class, class> class __list_imp;
-template <class, class> class __list_const_iterator;
+template <class _Tp, class _Alloc> class list;
+template <class _Tp, class _Alloc> class __list_imp;
+template <class _Tp, class _VoidPtr> class __list_const_iterator;
 
 template <class _Tp, class _VoidPtr>
 class _LIBCPP_VISIBLE __list_iterator
@@ -423,7 +423,7 @@ private:
     static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
     _LIBCPP_INLINE_VISIBILITY
@@ -447,7 +447,7 @@ private:
     void __move_assign_alloc(const __list_imp& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
         {
-            __node_alloc() = _STD::move(__c.__node_alloc());
+            __node_alloc() = _VSTD::move(__c.__node_alloc());
         }
 
     _LIBCPP_INLINE_VISIBILITY
@@ -503,8 +503,8 @@ __list_imp<_Tp, _Alloc>::clear() _NOEXCEPT
         {
             __node& __n = *__f.__ptr_;
             ++__f;
-            __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-            __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+            __node_alloc_traits::destroy(__na, _VSTD::addressof(__n.__value_));
+            __node_alloc_traits::deallocate(__na, _VSTD::addressof(__n), 1);
         }
     }
 }
@@ -515,7 +515,7 @@ __list_imp<_Tp, _Alloc>::swap(__list_imp& __c)
         _NOEXCEPT_(!__node_alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<__node_allocator>::value)
 {
-    using _STD::swap;
+    using _VSTD::swap;
     __swap_alloc(__node_alloc(), __c.__node_alloc());
     swap(__sz(), __c.__sz());
     swap(__end_, __c.__end_);
@@ -555,8 +555,8 @@ public:
     typedef typename base::difference_type           difference_type;
     typedef typename base::iterator                  iterator;
     typedef typename base::const_iterator            const_iterator;
-    typedef _STD::reverse_iterator<iterator>         reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator>   const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     list()
@@ -763,8 +763,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::__iterator(size_type __n)
 {
-    return __n <= base::__sz() / 2 ? _STD::next(begin(), __n)
-                                   : _STD::prev(end(), base::__sz() - __n);
+    return __n <= base::__sz() / 2 ? _VSTD::next(begin(), __n)
+                                   : _VSTD::prev(end(), base::__sz() - __n);
 }
 
 template <class _Tp, class _Alloc>
@@ -866,7 +866,7 @@ template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 list<_Tp, _Alloc>::list(list&& __c)
     _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value)
-    : base(allocator_type(_STD::move(__c.__node_alloc())))
+    : base(allocator_type(_VSTD::move(__c.__node_alloc())))
 {
     splice(end(), __c);
 }
@@ -969,7 +969,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
     __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
     ++base::__sz();
     return iterator(__hold.release());
@@ -987,7 +987,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
         typedef __allocator_destructor<__node_allocator> _D;
         unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
         __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
         __r = iterator(__hold.get());
         __hold.release();
@@ -999,7 +999,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold.get();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
@@ -1010,7 +1010,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
         {
             while (true)
             {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __node_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                 if (__prev == 0)
@@ -1040,7 +1040,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
         typedef __allocator_destructor<__node_allocator> _D;
         unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
         __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), *__f);
+        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
         ++__ds;
         __r = iterator(__hold.get());
         __hold.release();
@@ -1052,7 +1052,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
             for (++__f; __f != __l; ++__f, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), *__f);
+                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), *__f);
                 __e.__ptr_->__next_ = __hold.get();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
@@ -1063,7 +1063,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
         {
             while (true)
             {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __node_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                 if (__prev == 0)
@@ -1086,7 +1086,7 @@ list<_Tp, _Alloc>::push_front(const value_type& __x)
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(*base::__end_.__next_, *__hold, *__hold);
     ++base::__sz();
     __hold.release();
@@ -1099,7 +1099,7 @@ list<_Tp, _Alloc>::push_back(const value_type& __x)
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
     __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
     ++base::__sz();
     __hold.release();
@@ -1114,7 +1114,7 @@ list<_Tp, _Alloc>::push_front(value_type&& __x)
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes(*base::__end_.__next_, *__hold, *__hold);
     ++base::__sz();
     __hold.release();
@@ -1127,7 +1127,7 @@ list<_Tp, _Alloc>::push_back(value_type&& __x)
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
     ++base::__sz();
     __hold.release();
@@ -1143,7 +1143,7 @@ list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_nodes(*base::__end_.__next_, *__hold, *__hold);
     ++base::__sz();
     __hold.release();
@@ -1157,7 +1157,7 @@ list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
     __node_allocator& __na = base::__node_alloc();
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
     ++base::__sz();
     __hold.release();
@@ -1172,7 +1172,7 @@ list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
     __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::forward<_Args>(__args)...);
     __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
     ++base::__sz();
     return iterator(__hold.release());
@@ -1188,7 +1188,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
     typedef __allocator_destructor<__node_allocator> _D;
     unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
     __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), _VSTD::move(__x));
     __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
     ++base::__sz();
     return iterator(__hold.release());
@@ -1204,8 +1204,8 @@ list<_Tp, _Alloc>::pop_front()
     __node& __n = *base::__end_.__next_;
     base::__unlink_nodes(__n, __n);
     --base::__sz();
-    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, _VSTD::addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, _VSTD::addressof(__n), 1);
 }
 
 template <class _Tp, class _Alloc>
@@ -1216,8 +1216,8 @@ list<_Tp, _Alloc>::pop_back()
     __node& __n = *base::__end_.__prev_;
     base::__unlink_nodes(__n, __n);
     --base::__sz();
-    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, _VSTD::addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, _VSTD::addressof(__n), 1);
 }
 
 template <class _Tp, class _Alloc>
@@ -1229,8 +1229,8 @@ list<_Tp, _Alloc>::erase(const_iterator __p)
     __node_pointer __r = __n.__next_;
     base::__unlink_nodes(__n, __n);
     --base::__sz();
-    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, _VSTD::addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, _VSTD::addressof(__n), 1);
     return iterator(__r);
 }
 
@@ -1247,8 +1247,8 @@ list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
             __node& __n = const_cast<__node&>(*__f.__ptr_);
             ++__f;
             --base::__sz();
-            __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-            __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+            __node_alloc_traits::destroy(__na, _VSTD::addressof(__n.__value_));
+            __node_alloc_traits::deallocate(__na, _VSTD::addressof(__n), 1);
         }
     }
     return iterator(const_cast<__node_pointer>(__l.__ptr_));
@@ -1268,7 +1268,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
         typedef __allocator_destructor<__node_allocator> _D;
         unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
         __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_));
+        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
         ++__ds;
         iterator __r = iterator(__hold.release());
         iterator __e = __r;
@@ -1279,7 +1279,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_));
+                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_));
                 __e.__ptr_->__next_ = __hold.get();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
@@ -1290,7 +1290,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
         {
             while (true)
             {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __node_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                 if (__prev == 0)
@@ -1319,7 +1319,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
         typedef __allocator_destructor<__node_allocator> _D;
         unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
         __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+        __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
         ++__ds;
         iterator __r = iterator(__hold.release());
         iterator __e = __r;
@@ -1330,7 +1330,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
             for (--__n; __n != 0; --__n, ++__e, ++__ds)
             {
                 __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+                __node_alloc_traits::construct(__na, _VSTD::addressof(__hold->__value_), __x);
                 __e.__ptr_->__next_ = __hold.get();
                 __hold->__prev_ = __e.__ptr_;
                 __hold.release();
@@ -1341,7 +1341,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
         {
             while (true)
             {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, _VSTD::addressof(*__e));
                 __node_pointer __prev = __e.__ptr_->__prev_;
                 __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                 if (__prev == 0)
@@ -1375,7 +1375,7 @@ template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
 {
-    if (__p != __i && __p != _STD::next(__i))
+    if (__p != __i && __p != _VSTD::next(__i))
     {
         __node& __f = const_cast<__node&>(*__i.__ptr_);
         base::__unlink_nodes(__f, __f);
@@ -1393,7 +1393,7 @@ list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __f, con
     {
         if (this != &__c)
         {
-            size_type __s = _STD::distance(__f, __l);
+            size_type __s = _VSTD::distance(__f, __l);
             __c.__sz() -= __s;
             base::__sz() += __s;
         }
@@ -1413,7 +1413,7 @@ list<_Tp, _Alloc>::remove(const value_type& __x)
     {
         if (*__i == __x)
         {
-            iterator __j = _STD::next(__i);
+            iterator __j = _VSTD::next(__i);
             for (; __j != __e && *__j == __x; ++__j)
                 ;
             __i = erase(__i, __j);
@@ -1432,7 +1432,7 @@ list<_Tp, _Alloc>::remove_if(_Pred __pred)
     {
         if (__pred(*__i))
         {
-            iterator __j = _STD::next(__i);
+            iterator __j = _VSTD::next(__i);
             for (; __j != __e && __pred(*__j); ++__j)
                 ;
             __i = erase(__i, __j);
@@ -1457,7 +1457,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
 {
     for (iterator __i = begin(), __e = end(); __i != __e;)
     {
-        iterator __j = _STD::next(__i);
+        iterator __j = _VSTD::next(__i);
         for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
             ;
         if (++__i != __j)
@@ -1489,7 +1489,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
             if (__comp(*__f2, *__f1))
             {
                 size_type __ds = 1;
-                iterator __m2 = _STD::next(__f2);
+                iterator __m2 = _VSTD::next(__f2);
                 for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds)
                     ;
                 base::__sz() += __ds;
@@ -1498,7 +1498,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
                 __node& __l = *__m2.__ptr_->__prev_;
                 __f2 = __m2;
                 base::__unlink_nodes(__f, __l);
-                __m2 = _STD::next(__f1);
+                __m2 = _VSTD::next(__f1);
                 __link_nodes(*__f1.__ptr_, __f, __l);
                 __f1 = __m2;
             }
@@ -1547,12 +1547,12 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
         return __f1;
     }
     size_type __n2 = __n / 2;
-    iterator __e1 = _STD::next(__f1, __n2);
+    iterator __e1 = _VSTD::next(__f1, __n2);
     iterator  __r = __f1 = __sort(__f1, __e1, __n2, __comp);
     iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
     if (__comp(*__f2, *__f1))
     {
-        iterator __m2 = _STD::next(__f2);
+        iterator __m2 = _VSTD::next(__f2);
         for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
             ;
         __node& __f = *__f2.__ptr_;
@@ -1560,7 +1560,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
         __r = __f2;
         __e1 = __f2 = __m2;
         base::__unlink_nodes(__f, __l);
-        __m2 = _STD::next(__f1);
+        __m2 = _VSTD::next(__f1);
         __link_nodes(*__f1.__ptr_, __f, __l);
         __f1 = __m2;
     }
@@ -1570,7 +1570,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
     {
         if (__comp(*__f2, *__f1))
         {
-            iterator __m2 = _STD::next(__f2);
+            iterator __m2 = _VSTD::next(__f2);
             for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
                 ;
             __node& __f = *__f2.__ptr_;
@@ -1579,7 +1579,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
                 __e1 = __m2;
             __f2 = __m2;
             base::__unlink_nodes(__f, __l);
-            __m2 = _STD::next(__f1);
+            __m2 = _VSTD::next(__f1);
             __link_nodes(*__f1.__ptr_, __f, __l);
             __f1 = __m2;
         }
@@ -1597,8 +1597,8 @@ list<_Tp, _Alloc>::reverse() _NOEXCEPT
     {
         iterator __e = end();
         for (iterator __i = begin(); __i != __e; --__i)
-            _STD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_);
-        _STD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_);
+            _VSTD::swap(__i.__ptr_->__prev_, __i.__ptr_->__next_);
+        _VSTD::swap(__e.__ptr_->__prev_, __e.__ptr_->__next_);
     }
 }
 
@@ -1607,7 +1607,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
 {
-    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Tp, class _Alloc>
@@ -1615,7 +1615,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator< (const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Alloc>

include/locale

@@ -192,6 +192,11 @@ template <class charT> class messages_byname;
 
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+// Get the C locale object
+locale_t __cloc();
+#endif
+
 // OSX has nice foo_l() functions that let you turn off use of the global
 // locale.  Linux, not so much.  The following functions avoid the locale when
 // that's possible and otherwise do the wrong thing.  FIXME.
@@ -363,7 +368,7 @@ __scan_keyword(_InputIterator& __b, _InputIterator __e,
                bool __case_sensitive = true)
 {
     typedef typename iterator_traits<_InputIterator>::value_type _CharT;
-    size_t __nkw = _STD::distance(__kb, __ke);
+    size_t __nkw = _VSTD::distance(__kb, __ke);
     const unsigned char __doesnt_match = '\0';
     const unsigned char __might_match = '\1';
     const unsigned char __does_match = '\2';
@@ -2511,7 +2516,11 @@ class __time_put
 {
     locale_t __loc_;
 protected:
+#ifdef _LIBCPP_STABLE_APPLE_ABI
     _LIBCPP_ALWAYS_INLINE __time_put() : __loc_(0) {}
+#else   // _LIBCPP_STABLE_APPLE_ABI
+    _LIBCPP_ALWAYS_INLINE __time_put() : __loc_(__cloc()) {}
+#endif  // _LIBCPP_STABLE_APPLE_ABI
     __time_put(const char* __nm);
     __time_put(const string& __nm);
     ~__time_put();
@@ -2614,7 +2623,7 @@ time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
     char_type* __nb = __nar;
     char_type* __ne = __nb + 100;
     __do_put(__nb, __ne, __tm, __fmt, __mod);
-    return _STD::copy(__nb, __ne, __s);
+    return _VSTD::copy(__nb, __ne, __s);
 }
 
 extern template class time_put<char>;
@@ -3282,7 +3291,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
             break;
         case money_base::symbol:
             if (!__sym.empty() && (__flags & ios_base::showbase))
-                __me = _STD::copy(__sym.begin(), __sym.end(), __me);
+                __me = _VSTD::copy(__sym.begin(), __sym.end(), __me);
             break;
         case money_base::value:
             {
@@ -3341,7 +3350,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
     }
     // print rest of sign, if any
     if (__sn.size() > 1)
-        __me = _STD::copy(__sn.begin()+1, __sn.end(), __me);
+        __me = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
     // set alignment
     if ((__flags & ios_base::adjustfield) == ios_base::left)
         __mi = __me;
@@ -3716,8 +3725,8 @@ template<class _Codecvt, class _Elem, class _Wide_alloc, class _Byte_alloc>
 inline _LIBCPP_ALWAYS_INLINE
 wstring_convert<_Codecvt, _Elem, _Wide_alloc, _Byte_alloc>::
     wstring_convert(wstring_convert&& __wc)
-        : __byte_err_string_(_STD::move(__wc.__byte_err_string_)),
-          __wide_err_string_(_STD::move(__wc.__wide_err_string_)),
+        : __byte_err_string_(_VSTD::move(__wc.__byte_err_string_)),
+          __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
           __cvtptr_(__wc.__cvtptr_),
           __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtstate_)
 {
@@ -4010,7 +4019,7 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
             memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
             __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
             __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            streamsize __nmemb = _STD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
+            streamsize __nmemb = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
                                  static_cast<streamsize>(__extbufend_ - __extbufnext_));
             codecvt_base::result __r;
             state_type __svs = __st_;

include/map

@@ -516,17 +516,19 @@ public:
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
         if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
 };
 
-template <class, class, class, class> class map;
-template <class, class, class, class> class multimap;
-template <class> class __map_const_iterator;
+template <class _Key, class _Tp, class _Compare, class _Allocator>
+    class map;
+template <class _Key, class _Tp, class _Compare, class _Allocator>
+    class multimap;
+template <class _TreeIterator> class __map_const_iterator;
 
 template <class _TreeIterator>
 class _LIBCPP_VISIBLE __map_iterator
@@ -713,8 +715,8 @@ public:
     typedef typename __alloc_traits::difference_type       difference_type;
     typedef __map_iterator<typename __base::iterator>      iterator;
     typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
-    typedef _STD::reverse_iterator<iterator>               reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator>         const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>               reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit map(const key_compare& __comp = key_compare())
@@ -753,12 +755,19 @@ public:
             insert(__m.begin(), __m.end());
         }
 
+    _LIBCPP_INLINE_VISIBILITY
+    map& operator=(const map& __m)
+        {
+            __tree_ = __m.__tree_;
+            return *this;
+        }
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
     map(map&& __m)
         _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_STD::move(__m.__tree_))
+        : __tree_(_VSTD::move(__m.__tree_))
         {
         }
 
@@ -782,7 +791,7 @@ public:
     map& operator=(map&& __m)
         _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
         {
-            __tree_ = _STD::move(__m.__tree_);
+            __tree_ = _VSTD::move(__m.__tree_);
             return *this;
         }
 
@@ -867,16 +876,16 @@ public:
         emplace() {return __tree_.__emplace_unique();}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool>
         emplace(_A0&& __a0)
-            {return __tree_.__emplace_unique(_STD::forward<_A0>(__a0));}
+            {return __tree_.__emplace_unique(_VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class ..._Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         pair<iterator, bool>
         emplace(_A0&& __a0, _Args&& ...__args);
 
@@ -888,32 +897,32 @@ public:
         {return __tree_.__emplace_hint_unique(__p.__i_);}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator
         emplace_hint(const_iterator __p, _A0&& __a0)
-            {return __tree_.__emplace_hint_unique(__p.__i_, _STD::forward<_A0>(__a0));}
+            {return __tree_.__emplace_hint_unique(__p.__i_, _VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class ..._Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         iterator
         emplace_hint(const_iterator __p, _A0&& __a0, _Args&& ...__args);
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> insert(_P&& __p)
-            {return __tree_.__insert_unique(_STD::forward<_P>(__p));}
+            {return __tree_.__insert_unique(_VSTD::forward<_P>(__p));}
 
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert(const_iterator __pos, _P&& __p)
-            {return __tree_.__insert_unique(__pos.__i_, _STD::forward<_P>(__p));}
+            {return __tree_.__insert_unique(__pos.__i_, _VSTD::forward<_P>(__p));}
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -993,11 +1002,11 @@ private:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     __node_holder __construct_node();
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _A0, class ..._Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0, _Args&& ...__args);
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1095,7 +1104,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(const_iterator __hint,
     else if (__tree_.value_comp().key_comp()(__hint->first, __k))  // check after
     {
         // *__hint < __k
-        const_iterator __next = _STD::next(__hint);
+        const_iterator __next = _VSTD::next(__hint);
         if (__next == end() || __tree_.value_comp().key_comp()(__k, __next->first))
         {
             // *__hint < __k < *next(__hint)
@@ -1167,14 +1176,14 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(__node_base_const_pointer
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 map<_Key, _Tp, _Compare, _Allocator>::map(map&& __m, const allocator_type& __a)
-    : __tree_(_STD::move(__m.__tree_), __a)
+    : __tree_(_VSTD::move(__m.__tree_), __a)
 {
     if (__a != __m.get_allocator())
     {
         const_iterator __e = cend();
         while (!__m.empty())
             __tree_.__insert_unique(__e.__i_,
-                    _STD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
+                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
     }
 }
 
@@ -1184,9 +1193,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first));
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
@@ -1199,7 +1208,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
     __h.get_deleter().__second_constructed = true;
     return __h;
@@ -1215,9 +1224,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
@@ -1232,11 +1241,11 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(const key_type& __k)
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1268,7 +1277,7 @@ map<_Key, _Tp, _Compare, _Allocator>::operator[](key_type&& __k)
     __node_pointer __r = static_cast<__node_pointer>(__child);
     if (__child == nullptr)
     {
-        __node_holder __h = __construct_node(_STD::move(__k));
+        __node_holder __h = __construct_node(_VSTD::move(__k));
         __tree_.__insert_node_at(__parent, __child, __h.get());
         __r = __h.release();
     }
@@ -1307,13 +1316,13 @@ map<_Key, _Tp, _Compare, _Allocator>::at(const key_type& __k) const
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 template <class _A0, class ..._Args,
-          class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
+          class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
          >
 pair<typename map<_Key, _Tp, _Compare, _Allocator>::iterator, bool>
 map<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     pair<iterator, bool> __r = __tree_.__node_insert_unique(__h.get());
     if (__r.second)
         __h.release();
@@ -1322,14 +1331,14 @@ map<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 template <class _A0, class ..._Args,
-          class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
+          class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
          >
 typename map<_Key, _Tp, _Compare, _Allocator>::iterator
 map<_Key, _Tp, _Compare, _Allocator>::emplace_hint(const_iterator __p,
                                                    _A0&& __a0, _Args&& ...__args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     iterator __r = __tree_.__node_insert_unique(__p.__i_, __h.get());
     if (__r.__i_.__ptr_ == __h.get())
         __h.release();
@@ -1344,7 +1353,7 @@ bool
 operator==(const map<_Key, _Tp, _Compare, _Allocator>& __x,
            const map<_Key, _Tp, _Compare, _Allocator>& __y)
 {
-    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1353,7 +1362,7 @@ bool
 operator< (const map<_Key, _Tp, _Compare, _Allocator>& __x,
            const map<_Key, _Tp, _Compare, _Allocator>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1454,8 +1463,8 @@ public:
     typedef typename __alloc_traits::difference_type       difference_type;
     typedef __map_iterator<typename __base::iterator>      iterator;
     typedef __map_const_iterator<typename __base::const_iterator> const_iterator;
-    typedef _STD::reverse_iterator<iterator>               reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator>         const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>               reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>         const_reverse_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit multimap(const key_compare& __comp = key_compare())
@@ -1495,12 +1504,19 @@ public:
             insert(__m.begin(), __m.end());
         }
 
+    _LIBCPP_INLINE_VISIBILITY
+    multimap& operator=(const multimap& __m)
+        {
+            __tree_ = __m.__tree_;
+            return *this;
+        }
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
     multimap(multimap&& __m)
         _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_STD::move(__m.__tree_))
+        : __tree_(_VSTD::move(__m.__tree_))
         {
         }
 
@@ -1524,7 +1540,7 @@ public:
     multimap& operator=(multimap&& __m)
         _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
         {
-            __tree_ = _STD::move(__m.__tree_);
+            __tree_ = _VSTD::move(__m.__tree_);
             return *this;
         }
 
@@ -1599,16 +1615,16 @@ public:
     iterator emplace() {return __tree_.__emplace_multi();}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator
         emplace(_A0&& __a0)
-            {return __tree_.__emplace_multi(_STD::forward<_A0>(__a0));}
+            {return __tree_.__emplace_multi(_VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class ..._Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         iterator
         emplace(_A0&& __a0, _Args&& ...__args);
 
@@ -1619,32 +1635,32 @@ public:
         {return __tree_.__emplace_hint_multi(__p.__i_);}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator
         emplace_hint(const_iterator __p, _A0&& __a0)
-            {return __tree_.__emplace_hint_multi(__p.__i_, _STD::forward<_A0>(__a0));}
+            {return __tree_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class ..._Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         iterator
         emplace_hint(const_iterator __p, _A0&& __a0, _Args&& ...__args);
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert(_P&& __p)
-            {return __tree_.__insert_multi(_STD::forward<_P>(__p));}
+            {return __tree_.__insert_multi(_VSTD::forward<_P>(__p));}
 
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert(const_iterator __pos, _P&& __p)
-            {return __tree_.__insert_multi(__pos.__i_, _STD::forward<_P>(__p));}
+            {return __tree_.__insert_multi(__pos.__i_, _VSTD::forward<_P>(__p));}
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -1719,11 +1735,11 @@ private:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     __node_holder __construct_node();
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _A0, class ..._Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0, _Args&& ...__args);
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1733,14 +1749,14 @@ private:
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 multimap<_Key, _Tp, _Compare, _Allocator>::multimap(multimap&& __m, const allocator_type& __a)
-    : __tree_(_STD::move(__m.__tree_), __a)
+    : __tree_(_VSTD::move(__m.__tree_), __a)
 {
     if (__a != __m.get_allocator())
     {
         const_iterator __e = cend();
         while (!__m.empty())
             __tree_.__insert_multi(__e.__i_,
-                    _STD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
+                    _VSTD::move(__m.__tree_.remove(__m.begin().__i_)->__value_));
     }
 }
 
@@ -1750,23 +1766,23 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first));
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 template <class _A0,
-          class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
+          class // = typename enable_if<is_constructible<value_type, _A0>::value>::type
          >
 typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
 multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_), _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
     __h.get_deleter().__second_constructed = true;
     return __h;
@@ -1776,16 +1792,16 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 template <class _A0, class ..._Args,
-          class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
+          class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
          >
 typename multimap<_Key, _Tp, _Compare, _Allocator>::__node_holder
 multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__args)
 {
     __node_allocator& __na = __tree_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second), _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
@@ -1797,13 +1813,13 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&&
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 template <class _A0, class ..._Args,
-          class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
+          class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
          >
 typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
 multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     iterator __r = __tree_.__node_insert_multi(__h.get());
     __h.release();
     return __r;
@@ -1811,15 +1827,15 @@ multimap<_Key, _Tp, _Compare, _Allocator>::emplace(_A0&& __a0, _Args&& ...__args
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
 template <class _A0, class ..._Args,
-          class //= typename enable_if<is_convertible<_A0, _Key>::value>::type
+          class //= typename enable_if<is_constructible<_Key, _A0>::value>::type
          >
 typename multimap<_Key, _Tp, _Compare, _Allocator>::iterator
 multimap<_Key, _Tp, _Compare, _Allocator>::emplace_hint(const_iterator __p,
                                                         _A0&& __a0,
                                                         _Args&& ...__args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     iterator __r = __tree_.__node_insert_multi(__p.__i_, __h.get());
     __h.release();
     return __r;
@@ -1833,7 +1849,7 @@ bool
 operator==(const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
            const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
 {
-    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>
@@ -1842,7 +1858,7 @@ bool
 operator< (const multimap<_Key, _Tp, _Compare, _Allocator>& __x,
            const multimap<_Key, _Tp, _Compare, _Allocator>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Tp, class _Compare, class _Allocator>

include/memory

@@ -619,6 +619,46 @@ addressof(_Tp& __x) _NOEXCEPT
     return (_Tp*)&(char&)__x;
 }
 
+#if defined(_LIBCPP_HAS_OBJC_ARC) && !defined(_LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF)
+// Objective-C++ Automatic Reference Counting uses qualified pointers
+// that require special addressof() signatures. When
+// _LIBCPP_PREDEFINED_OBJC_ARC_ADDRESSOF is defined, the compiler
+// itself is providing these definitions. Otherwise, we provide them.
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__strong _Tp*
+addressof(__strong _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+
+#ifdef _LIBCPP_HAS_OBJC_ARC_WEAK
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__weak _Tp*
+addressof(__weak _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+#endif
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__autoreleasing _Tp*
+addressof(__autoreleasing _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+__unsafe_unretained _Tp*
+addressof(__unsafe_unretained _Tp& __x) _NOEXCEPT
+{
+  return &__x;
+}
+#endif
+
 template <class _Tp> class allocator;
 
 template <>
@@ -898,7 +938,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     static pointer pointer_to(typename conditional<is_void<element_type>::value,
                                       __nat, element_type>::type& __r) _NOEXCEPT
-        {return _STD::addressof(__r);}
+        {return _VSTD::addressof(__r);}
 };
 
 // allocator_traits
@@ -1032,7 +1072,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename pointer_traits<_Pointer>::element_type*
 __to_raw_pointer(_Pointer __p) _NOEXCEPT
 {
-    return _STD::__to_raw_pointer(__p.operator->());
+    return _VSTD::__to_raw_pointer(__p.operator->());
 }
 
 template <class _Tp>
@@ -1256,8 +1296,8 @@ struct __has_allocate_hint
 #ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
 
 template <class _Alloc, class _Tp, class ..._Args>
-decltype(_STD::declval<_Alloc>().construct(_STD::declval<_Tp*>(),
-                                           _STD::declval<_Args>()...),
+decltype(_VSTD::declval<_Alloc>().construct(_VSTD::declval<_Tp*>(),
+                                           _VSTD::declval<_Args>()...),
                                            true_type())
 __has_construct_test(_Alloc&& __a, _Tp* __p, _Args&& ...__args);
 
@@ -1427,7 +1467,7 @@ struct _LIBCPP_VISIBLE allocator_traits
         _LIBCPP_INLINE_VISIBILITY
         static void construct(allocator_type& __a, _Tp* __p, _Args&&... __args)
             {__construct(__has_construct<allocator_type, pointer, _Args...>(),
-                         __a, __p, _STD::forward<_Args>(__args)...);}
+                         __a, __p, _VSTD::forward<_Args>(__args)...);}
 #else  // _LIBCPP_HAS_NO_VARIADICS
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
@@ -1488,12 +1528,12 @@ private:
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(true_type, allocator_type& __a, _Tp* __p, _Args&&... __args)
-            {__a.construct(__p, _STD::forward<_Args>(__args)...);}
+            {__a.construct(__p, _VSTD::forward<_Args>(__args)...);}
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         static void __construct(false_type, allocator_type&, _Tp* __p, _Args&&... __args)
             {
-                ::new ((void*)__p) _Tp(_STD::forward<_Args>(__args)...);
+                ::new ((void*)__p) _Tp(_VSTD::forward<_Args>(__args)...);
             }
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 
@@ -1598,9 +1638,9 @@ public:
     _LIBCPP_INLINE_VISIBILITY allocator() _NOEXCEPT {}
     template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) _NOEXCEPT {}
     _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const _NOEXCEPT
-        {return _STD::addressof(__x);}
+        {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const _NOEXCEPT
-        {return _STD::addressof(__x);}
+        {return _VSTD::addressof(__x);}
     _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
         {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));}
     _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) _NOEXCEPT
@@ -1613,7 +1653,7 @@ public:
         void
         construct(_Up* __p, _Args&&... __args)
         {
-            ::new((void*)__p) _Up(_STD::forward<_Args>(__args)...);
+            ::new((void*)__p) _Up(_VSTD::forward<_Args>(__args)...);
         }
 #else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
         _LIBCPP_INLINE_VISIBILITY
@@ -1654,7 +1694,7 @@ public:
         >::type
         construct(pointer __p, _A0 __a0)
         {
-            ::new((void*)__p) _Tp(_STD::move(__a0));
+            ::new((void*)__p) _Tp(_VSTD::move(__a0));
         }
 # endif  // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
     template <class _A0, class _A1>
@@ -1843,19 +1883,54 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0)
-        : __first_(_STD::forward<_T1_param>(__t1)) {}
+        : __first_(_VSTD::forward<_T1_param>(__t1)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0)
-        : __second_(_STD::forward<_T2_param>(__t2)) {}
+        : __second_(_VSTD::forward<_T2_param>(__t2)) {}
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        : __first_(_STD::forward<_T1_param>(__t1)), __second_(_STD::forward<_T2_param>(__t2)) {}
+        : __first_(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {}
+
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
+                   is_nothrow_copy_constructible<_T2>::value)
+        : __first_(__p.first()),
+          __second_(__p.second()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
+                   is_nothrow_copy_assignable<_T2>::value)
+        {
+            __first_ = __p.first();
+            __second_ = __p.second();
+            return *this;
+        }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
         _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
                    is_nothrow_move_constructible<_T2>::value)
-        : __first_(_STD::forward<_T1>(__p.first())), __second_(_STD::forward<_T2>(__p.second())) {}
+        : __first_(_VSTD::forward<_T1>(__p.first())),
+          __second_(_VSTD::forward<_T2>(__p.second())) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
+                   is_nothrow_move_assignable<_T2>::value)
+        {
+            __first_ = _VSTD::forward<_T1>(__p.first());
+            __second_ = _VSTD::forward<_T2>(__p.second());
+            return *this;
+        }
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return __first_;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;}
 
@@ -1866,7 +1941,7 @@ public:
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T1>::value)
     {
-        using _STD::swap;
+        using _VSTD::swap;
         swap(__first_, __x.__first_);
         swap(__second_, __x.__second_);
     }
@@ -1890,19 +1965,52 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1, int = 0)
-        : _T1(_STD::forward<_T1_param>(__t1)) {}
+        : _T1(_VSTD::forward<_T1_param>(__t1)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2, int* = 0)
-        : __second_(_STD::forward<_T2_param>(__t2)) {}
+        : __second_(_VSTD::forward<_T2_param>(__t2)) {}
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        : _T1(_STD::forward<_T1_param>(__t1)), __second_(_STD::forward<_T2_param>(__t2)) {}
+        : _T1(_VSTD::forward<_T1_param>(__t1)), __second_(_VSTD::forward<_T2_param>(__t2)) {}
+
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
+                   is_nothrow_copy_constructible<_T2>::value)
+        : _T1(__p.first()), __second_(__p.second()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
+                   is_nothrow_copy_assignable<_T2>::value)
+        {
+            _T1::operator=(__p.first());
+            __second_ = __p.second();
+            return *this;
+        }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
         _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
                    is_nothrow_move_constructible<_T2>::value)
-        : _T1(_STD::move(__p.first())), __second_(_STD::forward<_T2>(__p.second())) {}
+        : _T1(_VSTD::move(__p.first())), __second_(_VSTD::forward<_T2>(__p.second())) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
+                   is_nothrow_move_assignable<_T2>::value)
+        {
+            _T1::operator=(_VSTD::move(__p.first()));
+            __second_ = _VSTD::forward<_T2>(__p.second());
+            return *this;
+        }
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;}
 
@@ -1913,7 +2021,7 @@ public:
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T1>::value)
     {
-        using _STD::swap;
+        using _VSTD::swap;
         swap(__second_, __x.__second_);
     }
 };
@@ -1936,19 +2044,54 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
-        : __first_(_STD::forward<_T1_param>(__t1)) {}
+        : __first_(_VSTD::forward<_T1_param>(__t1)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
-        : _T2(_STD::forward<_T2_param>(__t2)) {}
+        : _T2(_VSTD::forward<_T2_param>(__t2)) {}
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
         _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
                    is_nothrow_move_constructible<_T2>::value)
-        : _T2(_STD::forward<_T2_param>(__t2)), __first_(_STD::forward<_T1_param>(__t1)) {}
+        : _T2(_VSTD::forward<_T2_param>(__t2)), __first_(_VSTD::forward<_T1_param>(__t1)) {}
+
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
+                   is_nothrow_copy_constructible<_T2>::value)
+        : _T2(__p.second()), __first_(__p.first()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
+                   is_nothrow_copy_assignable<_T2>::value)
+        {
+            _T2::operator=(__p.second());
+            __first_ = __p.first();
+            return *this;
+        }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+    _LIBCPP_INLINE_VISIBILITY
     __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
-        : _T2(_STD::forward<_T2>(__p.second())), __first_(_STD::move(__p.first())) {}
+        _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
+                   is_nothrow_move_constructible<_T2>::value)
+        : _T2(_VSTD::forward<_T2>(__p.second())), __first_(_VSTD::move(__p.first())) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
+                   is_nothrow_move_assignable<_T2>::value)
+        {
+            _T2::operator=(_VSTD::forward<_T2>(__p.second()));
+            __first_ = _VSTD::move(__p.first());
+            return *this;
+        }
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return __first_;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return __first_;}
 
@@ -1959,7 +2102,7 @@ public:
         _NOEXCEPT_(__is_nothrow_swappable<_T1>::value &&
                    __is_nothrow_swappable<_T1>::value)
     {
-        using _STD::swap;
+        using _VSTD::swap;
         swap(__first_, __x.__first_);
     }
 };
@@ -1981,19 +2124,52 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp() {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T1_param __t1)
-        : _T1(_STD::forward<_T1_param>(__t1)) {}
+        : _T1(_VSTD::forward<_T1_param>(__t1)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __libcpp_compressed_pair_imp(_T2_param __t2)
-        : _T2(_STD::forward<_T2_param>(__t2)) {}
+        : _T2(_VSTD::forward<_T2_param>(__t2)) {}
     _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(_T1_param __t1, _T2_param __t2)
-        : _T1(_STD::forward<_T1_param>(__t1)), _T2(_STD::forward<_T2_param>(__t2)) {}
+        : _T1(_VSTD::forward<_T1_param>(__t1)), _T2(_VSTD::forward<_T2_param>(__t2)) {}
+
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
+                   is_nothrow_copy_constructible<_T2>::value)
+        : _T1(__p.first()), _T2(__p.second()) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(const __libcpp_compressed_pair_imp& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
+                   is_nothrow_copy_assignable<_T2>::value)
+        {
+            _T1::operator=(__p.first());
+            _T2::operator=(__p.second());
+            return *this;
+        }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp(__libcpp_compressed_pair_imp&& __p)
         _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
                    is_nothrow_move_constructible<_T2>::value)
-        : _T1(_STD::move(__p.first())), _T2(_STD::move(__p.second())) {}
+        : _T1(_VSTD::move(__p.first())), _T2(_VSTD::move(__p.second())) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __libcpp_compressed_pair_imp& operator=(__libcpp_compressed_pair_imp&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
+                   is_nothrow_move_assignable<_T2>::value)
+        {
+            _T1::operator=(_VSTD::move(__p.first()));
+            _T2::operator=(_VSTD::move(__p.second()));
+            return *this;
+        }
+
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return *this;}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return *this;}
 
@@ -2024,19 +2200,48 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY __compressed_pair() {}
     _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T1_param __t1, int = 0)
-        : base(_STD::forward<_T1_param>(__t1)) {}
+        : base(_VSTD::forward<_T1_param>(__t1)) {}
     _LIBCPP_INLINE_VISIBILITY explicit __compressed_pair(_T2_param __t2, int* = 0)
-        : base(_STD::forward<_T2_param>(__t2)) {}
+        : base(_VSTD::forward<_T2_param>(__t2)) {}
     _LIBCPP_INLINE_VISIBILITY __compressed_pair(_T1_param __t1, _T2_param __t2)
-        : base(_STD::forward<_T1_param>(__t1), _STD::forward<_T2_param>(__t2)) {}
+        : base(_VSTD::forward<_T1_param>(__t1), _VSTD::forward<_T2_param>(__t2)) {}
+
+#ifdef _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
+    _LIBCPP_INLINE_VISIBILITY
+    __compressed_pair(const __compressed_pair& __p)
+        _NOEXCEPT_(is_nothrow_copy_constructible<_T1>::value &&
+                   is_nothrow_copy_constructible<_T2>::value)
+        : base(__p) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __compressed_pair& operator=(const __compressed_pair& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<_T1>::value &&
+                   is_nothrow_copy_assignable<_T2>::value)
+        {
+            base::operator=(__p);
+            return *this;
+        }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     __compressed_pair(__compressed_pair&& __p)
         _NOEXCEPT_(is_nothrow_move_constructible<_T1>::value &&
                    is_nothrow_move_constructible<_T2>::value)
-        : base(_STD::move(__p)) {}
+        : base(_VSTD::move(__p)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    __compressed_pair& operator=(__compressed_pair&& __p)
+        _NOEXCEPT_(is_nothrow_move_assignable<_T1>::value &&
+                   is_nothrow_move_assignable<_T2>::value)
+        {
+            base::operator=(_VSTD::move(__p));
+            return *this;
+        }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
+#endif  // _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
+
     _LIBCPP_INLINE_VISIBILITY _T1_reference       first() _NOEXCEPT       {return base::first();}
     _LIBCPP_INLINE_VISIBILITY _T1_const_reference first() const _NOEXCEPT {return base::first();}
 
@@ -2127,7 +2332,7 @@ public:
                 "unique_ptr constructed with null function pointer deleter");
         }
     _LIBCPP_INLINE_VISIBILITY explicit unique_ptr(pointer __p) _NOEXCEPT
-        : __ptr_(_STD::move(__p))
+        : __ptr_(_VSTD::move(__p))
         {
             static_assert(!is_pointer<deleter_type>::value,
                 "unique_ptr constructed with null function pointer deleter");
@@ -2143,12 +2348,12 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, typename remove_reference<deleter_type>::type&& __d)
              _NOEXCEPT
-        : __ptr_(__p, _STD::move(__d))
+        : __ptr_(__p, _VSTD::move(__d))
         {
             static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
         }
     _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
-        : __ptr_(__u.release(), _STD::forward<deleter_type>(__u.get_deleter())) {}
+        : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
     template <class _Up, class _Ep>
         _LIBCPP_INLINE_VISIBILITY
         unique_ptr(unique_ptr<_Up, _Ep>&& __u,
@@ -2163,7 +2368,7 @@ public:
                          ),
                          __nat
                       >::type = __nat()) _NOEXCEPT
-            : __ptr_(__u.release(), _STD::forward<_Ep>(__u.get_deleter())) {}
+            : __ptr_(__u.release(), _VSTD::forward<_Ep>(__u.get_deleter())) {}
 
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY unique_ptr(auto_ptr<_Up>&& __p,
@@ -2179,7 +2384,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT
             {
                 reset(__u.release());
-                __ptr_.second() = _STD::forward<deleter_type>(__u.get_deleter());
+                __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
                 return *this;
             }
 
@@ -2193,7 +2398,7 @@ public:
             operator=(unique_ptr<_Up, _Ep>&& __u) _NOEXCEPT
             {
                 reset(__u.release());
-                __ptr_.second() = _STD::forward<_Ep>(__u.get_deleter());
+                __ptr_.second() = _VSTD::forward<_Ep>(__u.get_deleter());
                 return *this;
             }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2204,18 +2409,18 @@ public:
     }
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u)
-        : __ptr_(__u->release(), _STD::forward<deleter_type>(__u->get_deleter())) {}
+        : __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {}
 
     template <class _Up, class _Ep>
     _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr<_Up, _Ep> __u)
     {
         reset(__u.release());
-        __ptr_.second() = _STD::forward<deleter_type>(__u.get_deleter());
+        __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
         return *this;
     }
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d)
-        : __ptr_(_STD::move(__p), _STD::move(__d)) {}
+        : __ptr_(_VSTD::move(__p), _VSTD::move(__d)) {}
 
     template <class _Up>
         _LIBCPP_INLINE_VISIBILITY
@@ -2340,25 +2545,25 @@ public:
              >
     _LIBCPP_INLINE_VISIBILITY unique_ptr(_P __p, typename remove_reference<deleter_type>::type&& __d)
              _NOEXCEPT
-        : __ptr_(__p, _STD::move(__d))
+        : __ptr_(__p, _VSTD::move(__d))
         {
             static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
         }
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, typename remove_reference<deleter_type>::type&& __d)
              _NOEXCEPT
-        : __ptr_(pointer(), _STD::move(__d))
+        : __ptr_(pointer(), _VSTD::move(__d))
         {
             static_assert(!is_reference<deleter_type>::value, "rvalue deleter bound to reference");
         }
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(unique_ptr&& __u) _NOEXCEPT
-        : __ptr_(__u.release(), _STD::forward<deleter_type>(__u.get_deleter())) {}
+        : __ptr_(__u.release(), _VSTD::forward<deleter_type>(__u.get_deleter())) {}
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(unique_ptr&& __u) _NOEXCEPT
         {
             reset(__u.release());
-            __ptr_.second() = _STD::forward<deleter_type>(__u.get_deleter());
+            __ptr_.second() = _VSTD::forward<deleter_type>(__u.get_deleter());
             return *this;
         }
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2371,10 +2576,10 @@ public:
         }
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(pointer __p, deleter_type __d)
-        : __ptr_(__p, _STD::forward<deleter_type>(__d)) {}
+        : __ptr_(__p, _VSTD::forward<deleter_type>(__d)) {}
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(nullptr_t, deleter_type __d)
-        : __ptr_(pointer(), _STD::forward<deleter_type>(__d)) {}
+        : __ptr_(pointer(), _VSTD::forward<deleter_type>(__d)) {}
 
     _LIBCPP_INLINE_VISIBILITY operator __rv<unique_ptr>()
     {
@@ -2382,12 +2587,12 @@ public:
     }
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr(__rv<unique_ptr> __u)
-        : __ptr_(__u->release(), _STD::forward<deleter_type>(__u->get_deleter())) {}
+        : __ptr_(__u->release(), _VSTD::forward<deleter_type>(__u->get_deleter())) {}
 
     _LIBCPP_INLINE_VISIBILITY unique_ptr& operator=(__rv<unique_ptr> __u)
     {
         reset(__u->release());
-        __ptr_.second() = _STD::forward<deleter_type>(__u->get_deleter());
+        __ptr_.second() = _VSTD::forward<deleter_type>(__u->get_deleter());
         return *this;
     }
 
@@ -2507,7 +2712,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator>=(const unique_ptr<_T1, _D1>& __x, const unique_ptr<_T2, _D2>& __y) {return !(__x < __y);}
 
-template <class> struct hash;
+template <class _Tp> struct hash;
 
 template<class _Tp>
 struct _LIBCPP_VISIBLE hash<_Tp*>
@@ -2712,7 +2917,7 @@ class __shared_ptr_pointer
 public:
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
-        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _STD::move(__d)), _STD::move(__a)) {}
+        :  __data_(__compressed_pair<_Tp, _Dp>(__p, _VSTD::move(__d)), _VSTD::move(__a)) {}
 
 #ifndef _LIBCPP_NO_RTTI
     virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
@@ -2761,12 +2966,12 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     __shared_ptr_emplace(_Alloc __a)
-        :  __data_(_STD::move(__a)) {}
+        :  __data_(_VSTD::move(__a)) {}
 
     template <class ..._Args>
         _LIBCPP_INLINE_VISIBILITY
         __shared_ptr_emplace(_Alloc __a, _Args&& ...__args)
-            :  __data_(_STD::move(__a), _Tp(_STD::forward<_Args>(__args)...)) {}
+            :  __data_(_VSTD::move(__a), _Tp(_VSTD::forward<_Args>(__args)...)) {}
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
 
@@ -3231,7 +3436,7 @@ shared_ptr<_Tp>::make_shared(_Args&& ...__args)
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a2;
     unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-    ::new(__hold2.get()) _CntrlBlk(__a2, _STD::forward<_Args>(__args)...);
+    ::new(__hold2.get()) _CntrlBlk(__a2, _VSTD::forward<_Args>(__args)...);
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
@@ -3249,7 +3454,7 @@ shared_ptr<_Tp>::allocate_shared(const _Alloc& __a, _Args&& ...__args)
     typedef __allocator_destructor<_A2> _D2;
     _A2 __a2(__a);
     unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
-    ::new(__hold2.get()) _CntrlBlk(__a, _STD::forward<_Args>(__args)...);
+    ::new(__hold2.get()) _CntrlBlk(__a, _VSTD::forward<_Args>(__args)...);
     shared_ptr<_Tp> __r;
     __r.__ptr_ = __hold2.get()->get();
     __r.__cntrl_ = __hold2.release();
@@ -3437,7 +3642,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(shared_ptr&& __r) _NOEXCEPT
 {
-    shared_ptr(_STD::move(__r)).swap(*this);
+    shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
@@ -3447,7 +3652,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(shared_ptr<_Yp>&& __r)
 {
-    shared_ptr(_STD::move(__r)).swap(*this);
+    shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
@@ -3457,7 +3662,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(auto_ptr<_Yp>&& __r)
 {
-    shared_ptr(_STD::move(__r)).swap(*this);
+    shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
@@ -3467,7 +3672,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp>&& __r)
 {
-    shared_ptr(_STD::move(__r)).swap(*this);
+    shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
@@ -3489,7 +3694,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>&
 shared_ptr<_Tp>::operator=(unique_ptr<_Yp, _Dp> __r)
 {
-    shared_ptr(_STD::move(__r)).swap(*this);
+    shared_ptr(_VSTD::move(__r)).swap(*this);
     return *this;
 }
 
@@ -3500,8 +3705,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 shared_ptr<_Tp>::swap(shared_ptr& __r) _NOEXCEPT
 {
-    _STD::swap(__ptr_, __r.__ptr_);
-    _STD::swap(__cntrl_, __r.__cntrl_);
+    _VSTD::swap(__ptr_, __r.__ptr_);
+    _VSTD::swap(__cntrl_, __r.__cntrl_);
 }
 
 template<class _Tp>
@@ -3546,7 +3751,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>
 make_shared(_Args&& ...__args)
 {
-    return shared_ptr<_Tp>::make_shared(_STD::forward<_Args>(__args)...);
+    return shared_ptr<_Tp>::make_shared(_VSTD::forward<_Args>(__args)...);
 }
 
 template<class _Tp, class _Alloc, class ..._Args>
@@ -3554,7 +3759,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_ptr<_Tp>
 allocate_shared(const _Alloc& __a, _Args&& ...__args)
 {
-    return shared_ptr<_Tp>::allocate_shared(__a, _STD::forward<_Args>(__args)...);
+    return shared_ptr<_Tp>::allocate_shared(__a, _VSTD::forward<_Args>(__args)...);
 }
 
 #else  // _LIBCPP_HAS_NO_VARIADICS
@@ -3826,8 +4031,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT
 {
-    _STD::swap(__ptr_, __r.__ptr_);
-    _STD::swap(__cntrl_, __r.__cntrl_);
+    _VSTD::swap(__ptr_, __r.__ptr_);
+    _VSTD::swap(__cntrl_, __r.__cntrl_);
 }
 
 template<class _Tp>
@@ -3965,7 +4170,7 @@ void declare_reachable(void* __p);
 void declare_no_pointers(char* __p, size_t __n);
 void undeclare_no_pointers(char* __p, size_t __n);
 pointer_safety get_pointer_safety() _NOEXCEPT;
-void* __undeclare_reachable(void*);
+void* __undeclare_reachable(void* __p);
 
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -3975,7 +4180,7 @@ undeclare_reachable(_Tp* __p)
     return static_cast<_Tp*>(__undeclare_reachable(__p));
 }
 
-void* align(size_t, size_t, void*&, size_t&);
+void* align(size_t __align, size_t __sz, void*& __ptr, size_t& __space);
 
 _LIBCPP_END_NAMESPACE_STD
 

include/mutex

@@ -467,7 +467,7 @@ class __call_once_param
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
+    explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {}
 #else
     _LIBCPP_INLINE_VISIBILITY
     explicit __call_once_param(const _F& __f) : __f_(__f) {}
@@ -485,7 +485,7 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     void __execute(__tuple_indices<_Indices...>)
     {
-        __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...);
+        __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
     }
 };
 
@@ -498,7 +498,7 @@ class __call_once_param
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    explicit __call_once_param(_F&& __f) : __f_(_STD::move(__f)) {}
+    explicit __call_once_param(_F&& __f) : __f_(_VSTD::move(__f)) {}
 #else
     _LIBCPP_INLINE_VISIBILITY
     explicit __call_once_param(const _F& __f) : __f_(__f) {}
@@ -533,8 +533,8 @@ call_once(once_flag& __flag, _Callable&& __func, _Args&&... __args)
     if (__builtin_expect(__flag.__state_ , ~0ul) != ~0ul)
     {
         typedef tuple<typename decay<_Callable>::type, typename decay<_Args>::type...> _G;
-        __call_once_param<_G> __p(_G(__decay_copy(_STD::forward<_Callable>(__func)),
-                                __decay_copy(_STD::forward<_Args>(__args))...));
+        __call_once_param<_G> __p(_G(__decay_copy(_VSTD::forward<_Callable>(__func)),
+                                __decay_copy(_VSTD::forward<_Args>(__args))...));
         __call_once(__flag.__state_, &__p, &__call_once_proxy<_G>);
     }
 }

include/new

@@ -89,23 +89,23 @@ _LIBCPP_VISIBLE new_handler get_new_handler() _NOEXCEPT;
 
 }  // std
 
-_LIBCPP_VISIBLE void* operator new(std::size_t)
+_LIBCPP_VISIBLE void* operator new(std::size_t __sz)
 #if !__has_feature(cxx_noexcept)
     throw(std::bad_alloc)
 #endif
 ;
-_LIBCPP_VISIBLE void* operator new(std::size_t, const std::nothrow_t&) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete(void*) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete(void*, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_VISIBLE void* operator new(std::size_t __sz, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_VISIBLE void  operator delete(void* __p) _NOEXCEPT;
+_LIBCPP_VISIBLE void  operator delete(void* __p, const std::nothrow_t&) _NOEXCEPT;
 
-_LIBCPP_VISIBLE void* operator new[](std::size_t)
+_LIBCPP_VISIBLE void* operator new[](std::size_t __sz)
 #if !__has_feature(cxx_noexcept)
     throw(std::bad_alloc)
 #endif
 ;
-_LIBCPP_VISIBLE void* operator new[](std::size_t, const std::nothrow_t&) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete[](void*) _NOEXCEPT;
-_LIBCPP_VISIBLE void  operator delete[](void*, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_VISIBLE void* operator new[](std::size_t __sz, const std::nothrow_t&) _NOEXCEPT;
+_LIBCPP_VISIBLE void  operator delete[](void* __p) _NOEXCEPT;
+_LIBCPP_VISIBLE void  operator delete[](void* __p, const std::nothrow_t&) _NOEXCEPT;
 
 _LIBCPP_INLINE_VISIBILITY inline void* operator new  (std::size_t, void* __p) _NOEXCEPT {return __p;}
 _LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) _NOEXCEPT {return __p;}

include/ostream

@@ -154,11 +154,13 @@ public:
     virtual ~basic_ostream();
 protected:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_ostream(basic_ostream&& __rhs);
 #endif
 
     // 27.7.2.3 Assign/swap
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     basic_ostream& operator=(basic_ostream&& __rhs);
 #endif
     void swap(basic_ostream& __rhs);

include/queue

@@ -211,7 +211,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     queue(queue&& __q)
         _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_STD::move(__q.c)) {}
+        : c(_VSTD::move(__q.c)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
@@ -221,14 +221,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     queue& operator=(queue&& __q)
         _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _STD::move(__q.c); return *this;}
+        {c = _VSTD::move(__q.c); return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
     explicit queue(const container_type& __c)  : c(__c) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    explicit queue(container_type&& __c) : c(_STD::move(__c)) {}
+    explicit queue(container_type&& __c) : c(_VSTD::move(__c)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
@@ -254,13 +254,13 @@ public:
         queue(container_type&& __c, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
-            : c(_STD::move(__c), __a) {}
+            : c(_VSTD::move(__c), __a) {}
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         queue(queue&& __q, const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type* = 0)
-            : c(_STD::move(__q.c), __a) {}
+            : c(_VSTD::move(__q.c), __a) {}
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -282,12 +282,12 @@ public:
     void push(const value_type& __v) {c.push_back(__v);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void push(value_type&& __v)      {c.push_back(_STD::move(__v));}
+    void push(value_type&& __v)      {c.push_back(_VSTD::move(__v));}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void emplace(_Args&&... __args)
-            {c.emplace_back(_STD::forward<_Args>(__args)...);}
+            {c.emplace_back(_VSTD::forward<_Args>(__args)...);}
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
@@ -297,7 +297,7 @@ public:
     void swap(queue& __q)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
     {
-        using _STD::swap;
+        using _VSTD::swap;
         swap(c, __q.c);
     }
 
@@ -408,7 +408,7 @@ public:
     priority_queue(priority_queue&& __q)
         _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
                    is_nothrow_move_constructible<value_compare>::value)
-        : c(_STD::move(__q.c)), comp(_STD::move(__q.comp)) {}
+        : c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
@@ -420,7 +420,7 @@ public:
     priority_queue& operator=(priority_queue&& __q)
         _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
                    is_nothrow_move_assignable<value_compare>::value)
-        {c = _STD::move(__q.c); comp = _STD::move(__q.comp); return *this;}
+        {c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
@@ -498,7 +498,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp
     : c(__c),
       comp(__comp)
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -507,10 +507,10 @@ template <class _Tp, class _Container, class _Compare>
 inline _LIBCPP_INLINE_VISIBILITY
 priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& __comp,
                                                           container_type&& __c)
-    : c(_STD::move(__c)),
+    : c(_VSTD::move(__c)),
       comp(__comp)
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -523,7 +523,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
     : c(__f, __l),
       comp(__comp)
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
@@ -536,7 +536,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
       comp(__comp)
 {
     c.insert(c.end(), __f, __l);
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -547,11 +547,11 @@ inline _LIBCPP_INLINE_VISIBILITY
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                           const value_compare& __comp,
                                                           container_type&& __c)
-    : c(_STD::move(__c)),
+    : c(_VSTD::move(__c)),
       comp(__comp)
 {
     c.insert(c.end(), __f, __l);
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -589,7 +589,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
     : c(__c, __a),
       comp(__comp)
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
@@ -602,7 +602,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue&
     : c(__q.c, __a),
       comp(__q.comp)
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -615,10 +615,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type*)
-    : c(_STD::move(__c), __a),
+    : c(_VSTD::move(__c), __a),
       comp(__comp)
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 template <class _Tp, class _Container, class _Compare>
@@ -628,10 +628,10 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q,
                                                           const _Alloc& __a,
                        typename enable_if<uses_allocator<container_type,
                                                          _Alloc>::value>::type*)
-    : c(_STD::move(__q.c), __a),
-      comp(_STD::move(__q.comp))
+    : c(_VSTD::move(__q.c), __a),
+      comp(_VSTD::move(__q.comp))
 {
-    _STD::make_heap(c.begin(), c.end(), comp);
+    _VSTD::make_heap(c.begin(), c.end(), comp);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -642,7 +642,7 @@ void
 priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
 {
     c.push_back(__v);
-    _STD::push_heap(c.begin(), c.end(), comp);
+    _VSTD::push_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -652,8 +652,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
 {
-    c.push_back(_STD::move(__v));
-    _STD::push_heap(c.begin(), c.end(), comp);
+    c.push_back(_VSTD::move(__v));
+    _VSTD::push_heap(c.begin(), c.end(), comp);
 }
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -664,8 +664,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
 {
-    c.emplace_back(_STD::forward<_Args>(__args)...);
-    _STD::push_heap(c.begin(), c.end(), comp);
+    c.emplace_back(_VSTD::forward<_Args>(__args)...);
+    _VSTD::push_heap(c.begin(), c.end(), comp);
 }
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -676,7 +676,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::pop()
 {
-    _STD::pop_heap(c.begin(), c.end(), comp);
+    _VSTD::pop_heap(c.begin(), c.end(), comp);
     c.pop_back();
 }
 
@@ -687,7 +687,7 @@ priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
                    __is_nothrow_swappable<value_compare>::value)
 {
-    using _STD::swap;
+    using _VSTD::swap;
     swap(c, __q.c);
     swap(comp, __q.comp);
 }

include/random

@@ -2313,37 +2313,37 @@ operator==(const mersenne_twister_engine<_UI, _W, _N, _M, _R, _A, _U, _D, _S,
                                          _B, _T, _C, _L, _F>& __y)
 {
     if (__x.__i_ == __y.__i_)
-        return _STD::equal(__x.__x_, __x.__x_ + _N, __y.__x_);
+        return _VSTD::equal(__x.__x_, __x.__x_ + _N, __y.__x_);
     if (__x.__i_ == 0 || __y.__i_ == 0)
     {
-        size_t __j = _STD::min(_N - __x.__i_, _N - __y.__i_);
-        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
+        size_t __j = _VSTD::min(_N - __x.__i_, _N - __y.__i_);
+        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
                          __y.__x_ + __y.__i_))
             return false;
         if (__x.__i_ == 0)
-            return _STD::equal(__x.__x_ + __j, __x.__x_ + _N, __y.__x_);
-        return _STD::equal(__x.__x_, __x.__x_ + (_N - __j), __y.__x_ + __j);
+            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _N, __y.__x_);
+        return _VSTD::equal(__x.__x_, __x.__x_ + (_N - __j), __y.__x_ + __j);
     }
     if (__x.__i_ < __y.__i_)
     {
         size_t __j = _N - __y.__i_;
-        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
+        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
                          __y.__x_ + __y.__i_))
             return false;
-        if (!_STD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _N,
+        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _N,
                          __y.__x_))
             return false;
-        return _STD::equal(__x.__x_, __x.__x_ + __x.__i_,
+        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
                            __y.__x_ + (_N - (__x.__i_ + __j)));
     }
     size_t __j = _N - __x.__i_;
-    if (!_STD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
+    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
                      __x.__x_ + __x.__i_))
         return false;
-    if (!_STD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _N,
+    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _N,
                      __x.__x_))
         return false;
-    return _STD::equal(__y.__x_, __y.__x_ + __y.__i_,
+    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
                        __x.__x_ + (_N - (__y.__i_ + __j)));
 }
 
@@ -2621,37 +2621,37 @@ operator==(
     if (__x.__c_ != __y.__c_)
         return false;
     if (__x.__i_ == __y.__i_)
-        return _STD::equal(__x.__x_, __x.__x_ + _R, __y.__x_);
+        return _VSTD::equal(__x.__x_, __x.__x_ + _R, __y.__x_);
     if (__x.__i_ == 0 || __y.__i_ == 0)
     {
-        size_t __j = _STD::min(_R - __x.__i_, _R - __y.__i_);
-        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
+        size_t __j = _VSTD::min(_R - __x.__i_, _R - __y.__i_);
+        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
                          __y.__x_ + __y.__i_))
             return false;
         if (__x.__i_ == 0)
-            return _STD::equal(__x.__x_ + __j, __x.__x_ + _R, __y.__x_);
-        return _STD::equal(__x.__x_, __x.__x_ + (_R - __j), __y.__x_ + __j);
+            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _R, __y.__x_);
+        return _VSTD::equal(__x.__x_, __x.__x_ + (_R - __j), __y.__x_ + __j);
     }
     if (__x.__i_ < __y.__i_)
     {
         size_t __j = _R - __y.__i_;
-        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
+        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
                          __y.__x_ + __y.__i_))
             return false;
-        if (!_STD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _R,
+        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _R,
                          __y.__x_))
             return false;
-        return _STD::equal(__x.__x_, __x.__x_ + __x.__i_,
+        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
                            __y.__x_ + (_R - (__x.__i_ + __j)));
     }
     size_t __j = _R - __x.__i_;
-    if (!_STD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
+    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
                      __x.__x_ + __x.__i_))
         return false;
-    if (!_STD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _R,
+    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _R,
                      __x.__x_))
         return false;
-    return _STD::equal(__y.__x_, __y.__x_ + __y.__i_,
+    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
                        __x.__x_ + (_R - (__y.__i_ + __j)));
 }
 
@@ -2744,7 +2744,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit discard_block_engine(_Engine&& __e)
-        : __e_(_STD::move(__e)), __n_(0) {}
+        : __e_(_VSTD::move(__e)), __n_(0) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
@@ -2944,7 +2944,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit independent_bits_engine(_Engine&& __e)
-        : __e_(_STD::move(__e)) {}
+        : __e_(_VSTD::move(__e)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
@@ -3167,7 +3167,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit shuffle_order_engine(_Engine&& __e)
-        : __e_(_STD::move(__e)) {__init();}
+        : __e_(_VSTD::move(__e)) {__init();}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
@@ -3292,7 +3292,7 @@ operator==(
     const shuffle_order_engine<_Eng, _K>& __x,
     const shuffle_order_engine<_Eng, _K>& __y)
 {
-    return __x._Y_ == __y._Y_ && _STD::equal(__x._V_, __x._V_ + _K, __y._V_) &&
+    return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _K, __y._V_) &&
            __x.__e_ == __y.__e_;
 }
 
@@ -3418,7 +3418,7 @@ public:
     template<class _OutputIterator>
         _LIBCPP_INLINE_VISIBILITY
         void param(_OutputIterator __dest) const
-            {_STD::copy(__v_.begin(), __v_.end(), __dest);}
+            {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
 
 private:
     // no copy functions
@@ -3443,7 +3443,7 @@ seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
     if (__first != __last)
     {
-        _STD::fill(__first, __last, 0x8b8b8b8b);
+        _VSTD::fill(__first, __last, 0x8b8b8b8b);
         const size_t __n = static_cast<size_t>(__last - __first);
         const size_t __s = __v_.size();
         const size_t __t = (__n >= 623) ? 11
@@ -3453,7 +3453,7 @@ seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
                          : (__n - 1) / 2;
         const size_t __p = (__n - __t) / 2;
         const size_t __q = __p + __t;
-        const size_t __m = _STD::max(__s + 1, __n);
+        const size_t __m = _VSTD::max(__s + 1, __n);
         // __k = 0;
         {
             result_type __r = 1664525 * _T(__first[0] ^ __first[__p]
@@ -3639,7 +3639,7 @@ typename uniform_real_distribution<_RealType>::result_type
 uniform_real_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
     return (__p.b() - __p.a())
-        * _STD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
+        * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
         + __p.a();
 }
 
@@ -3871,9 +3871,9 @@ binomial_distribution<_IntType>::param_type::param_type(result_type __t, double
     if (0 < __p_ && __p_ < 1)
     {
         __r0_ = static_cast<result_type>((__t_ + 1) * __p_);
-        __pr_ = _STD::exp(_STD::lgamma(__t_ + 1.) - _STD::lgamma(__r0_ + 1.) -
-                          _STD::lgamma(__t_ - __r0_ + 1.) + __r0_ * _STD::log(__p_) +
-                          (__t_ - __r0_) * _STD::log(1 - __p_));
+        __pr_ = _VSTD::exp(_VSTD::lgamma(__t_ + 1.) - _VSTD::lgamma(__r0_ + 1.) -
+                          _VSTD::lgamma(__t_ - __r0_ + 1.) + __r0_ * _VSTD::log(__p_) +
+                          (__t_ - __r0_) * _VSTD::log(1 - __p_));
         __odds_ratio_ = __p_ / (1 - __p_);
     }
 }
@@ -4025,10 +4025,10 @@ template<class _URNG>
 _RealType
 exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
-    return -_STD::log
+    return -_VSTD::log
                   (
                       result_type(1) -
-                      _STD::generate_canonical<result_type,
+                      _VSTD::generate_canonical<result_type,
                                        numeric_limits<result_type>::digits>(__g)
                   )
                   / __p.lambda();
@@ -4180,7 +4180,7 @@ normal_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
             __v = _Uni(__g);
             __s = __u * __u + __v * __v;
         } while (__s > 1 || __s == 0);
-        result_type _F = _STD::sqrt(-2 * _STD::log(__s) / __s);
+        result_type _F = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
         _V_ = __v * _F;
         _V_hot_ = true;
         _U = __u * _F;
@@ -4297,7 +4297,7 @@ public:
     template<class _URNG>
         _LIBCPP_INLINE_VISIBILITY
         result_type operator()(_URNG& __g, const param_type& __p)
-        {return _STD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
+        {return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
@@ -4446,7 +4446,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
     {
         __s_ = 0;
         __d_ = 0;
-        __l_ = _STD::exp(-__mean_);
+        __l_ = _VSTD::exp(-__mean_);
         __omega_ = 0;
         __c3_ = 0;
         __c2_ = 0;
@@ -4456,7 +4456,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
     }
     else
     {
-        __s_ = _STD::sqrt(__mean_);
+        __s_ = _VSTD::sqrt(__mean_);
         __d_ = 6 * __mean_ * __mean_;
         __l_ = static_cast<result_type>(__mean_ - 1.1484);
         __omega_ = .3989423 / __s_;
@@ -4523,20 +4523,20 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
                 const result_type __fac[] = {1, 1, 2, 6, 24, 120, 720, 5040,
                                              40320, 362880};
                 __px = -__pr.__mean_;
-                __py = _STD::pow(__pr.__mean_, (double)__x) / __fac[__x];
+                __py = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
             }
             else
             {
                 double __del = .8333333E-1 / __x;
                 __del -= 4.8 * __del * __del * __del;
                 double __v = __difmuk / __x;
-                if (_STD::abs(__v) > 0.25)
-                    __px = __x * _STD::log(1 + __v) - __difmuk - __del;
+                if (_VSTD::abs(__v) > 0.25)
+                    __px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
                 else
                     __px = __x * __v * __v * (((((((.1250060 * __v + -.1384794) *
                            __v + .1421878) * __v + -.1661269) * __v + .2000118) *
                            __v + -.2500068) * __v + .3333333) * __v + -.5) - __del;
-                __py = .3989423 / _STD::sqrt(__x);
+                __py = .3989423 / _VSTD::sqrt(__x);
             }
             double __r = (0.5 - __difmuk) / __pr.__s_;
             double __r2 = __r * __r;
@@ -4545,13 +4545,13 @@ poisson_distribution<_IntType>::operator()(_URNG& __urng, const param_type& __pr
                                         __r2 + __pr.__c1_) * __r2 + __pr.__c0_);
             if (__using_exp_dist)
             {
-                if (__pr.__c_ * _STD::abs(__u) <= __py * _STD::exp(__px + __e) -
-                                                   __fy * _STD::exp(__fx + __e))
+                if (__pr.__c_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
+                                                   __fy * _VSTD::exp(__fx + __e))
                     break;
             }
             else
             {
-                if (__fy - __u * __fy <= __py * _STD::exp(__px - __fx))
+                if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
                     break;
             }
         }
@@ -4642,7 +4642,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         result_type operator()(_URNG& __g, const param_type& __p)
         {return __p.b() *
-            _STD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
+            _VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
 
     // property functions
     _LIBCPP_INLINE_VISIBILITY
@@ -4786,7 +4786,7 @@ _RealType
 extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
     return __p.a() - __p.b() *
-         _STD::log(-_STD::log(1-uniform_real_distribution<result_type>()(__g)));
+         _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
 }
 
 template <class _CharT, class _Traits, class _RT>
@@ -4923,7 +4923,7 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
             const result_type __w = __u * (1 - __u);
             if (__w != 0)
             {
-                const result_type __y = _STD::sqrt(__c / __w) *
+                const result_type __y = _VSTD::sqrt(__c / __w) *
                                         (__u - result_type(0.5));
                 __x = __b + __y;
                 if (__x >= 0)
@@ -4931,7 +4931,7 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
                     const result_type __z = 64 * __w * __w * __w * __v * __v;
                     if (__z <= 1 - 2 * __y * __y / __x)
                         break;
-                    if (_STD::log(__z) <= 2 * (__b * _STD::log(__x / __b) - __y))
+                    if (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
                         break;
                 }
             }
@@ -4945,14 +4945,14 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
             const result_type __es = __egen(__g);
             if (__u <= 1 - __a)
             {
-                __x = _STD::pow(__u, 1 / __a);
+                __x = _VSTD::pow(__u, 1 / __a);
                 if (__x <= __es)
                     break;
             }
             else
             {
-                const result_type __e = -_STD::log((1-__u)/__a);
-                __x = _STD::pow(1 - __a + __a * __e, 1 / __a);
+                const result_type __e = -_VSTD::log((1-__u)/__a);
+                __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
                 if (__x <= __e + __es)
                     break;
             }
@@ -5424,7 +5424,7 @@ cauchy_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
     uniform_real_distribution<result_type> __gen;
     // purposefully let tan arg get as close to pi/2 as it wants, tan will return a finite
-    return __p.a() + __p.b() * _STD::tan(3.1415926535897932384626433832795 * __gen(__g));
+    return __p.a() + __p.b() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
@@ -5662,7 +5662,7 @@ _RealType
 student_t_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
     gamma_distribution<result_type> __gd(__p.n() * .5, 2);
-    return __nd_(__g) * _STD::sqrt(__p.n()/__gd(__g));
+    return __nd_(__g) * _VSTD::sqrt(__p.n()/__gd(__g));
 }
 
 template <class _CharT, class _Traits, class _RT>
@@ -5843,12 +5843,12 @@ discrete_distribution<_IntType>::param_type::__init()
     {
         if (__p_.size() > 1)
         {
-            double __s = _STD::accumulate(__p_.begin(), __p_.end(), 0.0);
-            for (_STD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
+            double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
+            for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
                                                                        __i < __e; ++__i)
                 *__i /= __s;
             vector<double> __t(__p_.size() - 1);
-            _STD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
+            _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
             swap(__p_, __t);
         }
         else
@@ -5864,8 +5864,8 @@ vector<double>
 discrete_distribution<_IntType>::param_type::probabilities() const
 {
     size_t __n = __p_.size();
-    _STD::vector<double> __p(__n+1);
-    _STD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
+    _VSTD::vector<double> __p(__n+1);
+    _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
     if (__n > 0)
         __p[__n] = 1 - __p_[__n-1];
     else
@@ -5880,7 +5880,7 @@ discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
 {
     uniform_real_distribution<double> __gen;
     return static_cast<_IntType>(
-           _STD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
+           _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
                                                               __p.__p_.begin());
 }
 
@@ -6079,14 +6079,14 @@ void
 piecewise_constant_distribution<_RealType>::param_type::__init()
 {
     // __densities_ contains non-normalized areas
-    result_type __total_area = _STD::accumulate(__densities_.begin(),
+    result_type __total_area = _VSTD::accumulate(__densities_.begin(),
                                                 __densities_.end(),
                                                 result_type());
     for (size_t __i = 0; __i < __densities_.size(); ++__i)
         __densities_[__i] /= __total_area;
     // __densities_ contains normalized areas
     __areas_.assign(__densities_.size(), result_type());
-    _STD::partial_sum(__densities_.begin(), __densities_.end() - 1,
+    _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
                                                           __areas_.begin() + 1);
     // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
     __densities_.back() = 1 - __areas_.back();  // correct round off error
@@ -6175,7 +6175,7 @@ piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_t
 {
     typedef uniform_real_distribution<result_type> _Gen;
     result_type __u = _Gen()(__g);
-    ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
+    ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                       __u) - __p.__areas_.begin() - 1;
     return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
 }
@@ -6496,7 +6496,7 @@ piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_typ
 {
     typedef uniform_real_distribution<result_type> _Gen;
     result_type __u = _Gen()(__g);
-    ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
+    ptrdiff_t __k = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                       __u) - __p.__areas_.begin() - 1;
     __u -= __p.__areas_[__k];
     const result_type __dk = __p.__densities_[__k];
@@ -6508,7 +6508,7 @@ piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_typ
     const result_type __bk1 = __p.__b_[__k+1];
     const result_type __deltab = __bk1 - __bk;
     return (__bk * __dk1 - __bk1 * __dk +
-        _STD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
+        _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
         __deltad;
 }
 

include/regex

@@ -1280,7 +1280,7 @@ class __node
     __node(const __node&);
     __node& operator=(const __node&);
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __node() {}
@@ -1300,7 +1300,7 @@ class __end_state
     : public __node<_CharT>
 {
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __end_state() {}
@@ -1365,7 +1365,7 @@ class __empty_state
     typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __empty_state(__node<_CharT>* __s)
@@ -1391,7 +1391,7 @@ class __empty_non_own_state
     typedef __has_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __empty_non_own_state(__node<_CharT>* __s)
@@ -1417,7 +1417,7 @@ class __repeat_one_loop
     typedef __has_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __repeat_one_loop(__node<_CharT>* __s)
@@ -1479,7 +1479,7 @@ class __loop
     bool __greedy_;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __loop(unsigned __loop_id,
@@ -1578,7 +1578,7 @@ class __alternate
     typedef __owns_two_states<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __alternate(__owns_one_state<_CharT>* __s1,
@@ -1617,7 +1617,7 @@ class __begin_marked_subexpression
 
     unsigned __mexp_;
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __begin_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
@@ -1645,7 +1645,7 @@ class __end_marked_subexpression
 
     unsigned __mexp_;
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __end_marked_subexpression(unsigned __mexp, __node<_CharT>* __s)
@@ -1674,7 +1674,7 @@ class __back_ref
 
     unsigned __mexp_;
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __back_ref(unsigned __mexp, __node<_CharT>* __s)
@@ -1692,7 +1692,7 @@ __back_ref<_CharT>::__exec(__state& __s) const
     {
         ptrdiff_t __len = __sm.second - __sm.first;
         if (__s.__last_ - __s.__current_ >= __len &&
-            _STD::equal(__sm.first, __sm.second, __s.__current_))
+            _VSTD::equal(__sm.first, __sm.second, __s.__current_))
         {
             __s.__do_ = __state::__accept_but_not_consume;
             __s.__current_ += __len;
@@ -1722,7 +1722,7 @@ class __back_ref_icase
     _Traits __traits_;
     unsigned __mexp_;
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __back_ref_icase(const _Traits& __traits, unsigned __mexp,
@@ -1777,7 +1777,7 @@ class __back_ref_collate
     _Traits __traits_;
     unsigned __mexp_;
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __back_ref_collate(const _Traits& __traits, unsigned __mexp,
@@ -1832,7 +1832,7 @@ class __word_boundary
     _Traits __traits_;
     bool __invert_;
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit __word_boundary(const _Traits& __traits, bool __invert,
@@ -1900,7 +1900,7 @@ class __l_anchor
     typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __l_anchor(__node<_CharT>* __s)
@@ -1934,7 +1934,7 @@ class __r_anchor
     typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __r_anchor(__node<_CharT>* __s)
@@ -1968,7 +1968,7 @@ class __match_any
     typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_any(__node<_CharT>* __s)
@@ -2003,7 +2003,7 @@ class __match_any_but_newline
     typedef __owns_one_state<_CharT> base;
 
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_any_but_newline(__node<_CharT>* __s)
@@ -2025,7 +2025,7 @@ class __match_char
     __match_char(const __match_char&);
     __match_char& operator=(const __match_char&);
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char(_CharT __c, __node<_CharT>* __s)
@@ -2065,7 +2065,7 @@ class __match_char_icase
     __match_char_icase(const __match_char_icase&);
     __match_char_icase& operator=(const __match_char_icase&);
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char_icase(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
@@ -2106,7 +2106,7 @@ class __match_char_collate
     __match_char_collate(const __match_char_collate&);
     __match_char_collate& operator=(const __match_char_collate&);
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __match_char_collate(const _Traits& __traits, _CharT __c, __node<_CharT>* __s)
@@ -2158,7 +2158,7 @@ class __bracket_expression
     __bracket_expression(const __bracket_expression&);
     __bracket_expression& operator=(const __bracket_expression&);
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __bracket_expression(const _Traits& __traits, __node<_CharT>* __s,
@@ -2226,7 +2226,7 @@ public:
                     __b[0] = __traits_.translate_nocase(__b[0]);
                     __e[0] = __traits_.translate_nocase(__e[0]);
                 }
-                __ranges_.push_back(make_pair(_STD::move(__b), _STD::move(__e)));
+                __ranges_.push_back(make_pair(_VSTD::move(__b), _VSTD::move(__e)));
             }
         }
     _LIBCPP_INLINE_VISIBILITY
@@ -2263,7 +2263,7 @@ __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
         ++__consumed;
         if (__might_have_digraph_)
         {
-            const _CharT* __next = _STD::next(__s.__current_);
+            const _CharT* __next = _VSTD::next(__s.__current_);
             if (__next != __s.__last_)
             {
                 pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
@@ -2410,7 +2410,7 @@ __exit:
     }
 }
 
-template <class, class> class __lookahead;
+template <class _CharT, class _Traits> class __lookahead;
 
 template <class _CharT, class _Traits = regex_traits<_CharT> >
 class _LIBCPP_VISIBLE basic_regex
@@ -2430,8 +2430,8 @@ private:
     shared_ptr<__empty_state<_CharT> > __start_;
     __owns_one_state<_CharT>* __end_;
 
-    typedef _STD::__state<_CharT> __state;
-    typedef _STD::__node<_CharT> __node;
+    typedef _VSTD::__state<_CharT> __state;
+    typedef _VSTD::__node<_CharT> __node;
 
 public:
     // constants:
@@ -2834,7 +2834,7 @@ template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
 {
-    using _STD::swap;
+    using _VSTD::swap;
     swap(__traits_, __r.__traits_);
     swap(__flags_, __r.__flags_);
     swap(__marked_count_, __r.__marked_count_);
@@ -2866,7 +2866,7 @@ class __lookahead
     __lookahead(const __lookahead&);
     __lookahead& operator=(const __lookahead&);
 public:
-    typedef _STD::__state<_CharT> __state;
+    typedef _VSTD::__state<_CharT> __state;
 
     _LIBCPP_INLINE_VISIBILITY
     __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s)
@@ -2953,7 +2953,7 @@ basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
             __first = __parse_RE_expression(__first, __last);
             if (__first != __last)
             {
-                _ForwardIterator __temp = _STD::next(__first);
+                _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp == __last && *__first == '$')
                 {
                     __push_r_anchor();
@@ -3182,7 +3182,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '(')
@@ -3200,7 +3200,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == ')')
@@ -3218,7 +3218,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '{')
@@ -3236,7 +3236,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && *__temp == '}')
@@ -3254,7 +3254,7 @@ basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\' && '1' <= *__temp && *__temp <= '9')
@@ -3275,7 +3275,7 @@ basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp == __last && *__first == '$')
             return __first;
         // Not called inside a bracket
@@ -3333,7 +3333,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
@@ -3364,7 +3364,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
 {
     if (__first != __last)
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         if (__temp != __last)
         {
             if (*__first == '\\')
@@ -3674,7 +3674,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
 {
     if (__first != __last && *__first != ']')
     {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = _VSTD::next(__first);
         basic_string<_CharT> __start_range;
         if (__temp != __last && *__first == '[')
         {
@@ -3703,7 +3703,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
         }
         if (__first != __last && *__first != ']')
         {
-            __temp = _STD::next(__first);
+            __temp = _VSTD::next(__first);
             if (__temp != __last && *__first == '-' && *__temp != ']')
             {
                 // parse a range
@@ -3729,7 +3729,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
                         ++__first;
                     }
                 }
-                __ml->__add_range(_STD::move(__start_range), _STD::move(__end_range));
+                __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
             }
             else
             {
@@ -3890,7 +3890,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
     // Found [=
     //   This means =] must exist
     value_type _Equal_close[2] = {'=', ']'};
-    _ForwardIterator __temp = _STD::search(__first, __last, _Equal_close,
+    _ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
                                                             _Equal_close+2);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__temp == __last)
@@ -3925,7 +3925,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
 #endif  // _LIBCPP_NO_EXCEPTIONS
         }
     }
-    __first = _STD::next(__temp, 2);
+    __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
@@ -3939,7 +3939,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
     // Found [:
     //   This means :] must exist
     value_type _Colon_close[2] = {':', ']'};
-    _ForwardIterator __temp = _STD::search(__first, __last, _Colon_close,
+    _ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
                                                             _Colon_close+2);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__temp == __last)
@@ -3954,7 +3954,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
         throw regex_error(regex_constants::error_brack);
 #endif  // _LIBCPP_NO_EXCEPTIONS
     __ml->__add_class(__class_type);
-    __first = _STD::next(__temp, 2);
+    __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
@@ -3968,7 +3968,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
     // Found [.
     //   This means .] must exist
     value_type _Dot_close[2] = {'.', ']'};
-    _ForwardIterator __temp = _STD::search(__first, __last, _Dot_close,
+    _ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
                                                             _Dot_close+2);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (__temp == __last)
@@ -3987,7 +3987,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
         throw regex_error(regex_constants::error_collate);
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
-    __first = _STD::next(__temp, 2);
+    __first = _VSTD::next(__temp, 2);
     return __first;
 }
 
@@ -4091,7 +4091,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
             break;
         case '\\':
             {
-                _ForwardIterator __temp = _STD::next(__first);
+                _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp != __last)
                 {
                     if (*__temp == 'b')
@@ -4109,7 +4109,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
             break;
         case '(':
             {
-                _ForwardIterator __temp = _STD::next(__first);
+                _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp != __last && *__temp == '?')
                 {
                     if (++__temp != __last)
@@ -4121,7 +4121,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                 basic_regex __exp;
                                 __exp.__flags_ = __flags_;
                                 __temp = __exp.__parse(++__temp, __last);
-                                __push_lookahead(_STD::move(__exp), false);
+                                __push_lookahead(_VSTD::move(__exp), false);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                 if (__temp == __last || *__temp != ')')
                                     throw regex_error(regex_constants::error_paren);
@@ -4134,7 +4134,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                 basic_regex __exp;
                                 __exp.__flags_ = __flags_;
                                 __temp = __exp.__parse(++__temp, __last);
-                                __push_lookahead(_STD::move(__exp), true);
+                                __push_lookahead(_VSTD::move(__exp), true);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                 if (__temp == __last || *__temp != ')')
                                     throw regex_error(regex_constants::error_paren);
@@ -4179,7 +4179,7 @@ basic_regex<_CharT, _Traits>::__parse_atom(_ForwardIterator __first,
                 if (__first == __last)
                     throw regex_error(regex_constants::error_paren);
 #endif  // _LIBCPP_NO_EXCEPTIONS
-                _ForwardIterator __temp = _STD::next(__first);
+                _ForwardIterator __temp = _VSTD::next(__first);
                 if (__temp != __last && *__first == '?' && *__temp == ':')
                 {
                     ++__open_count_;
@@ -4223,7 +4223,7 @@ basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
 {
     if (__first != __last && *__first == '\\')
     {
-        _ForwardIterator __t1 = _STD::next(__first);
+        _ForwardIterator __t1 = _VSTD::next(__first);
         _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
         if (__t2 != __t1)
             __first = __t2;
@@ -4369,7 +4369,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
             ++__first;
             break;
         case 'c':
-            if ((__t = _STD::next(__first)) != __last)
+            if ((__t = _VSTD::next(__first)) != __last)
             {
                 if ('A' <= *__t <= 'Z' || 'a' <= *__t <= 'z')
                 {
@@ -4494,7 +4494,7 @@ basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
                                            _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __t1 = _STD::find(__first, __last, _CharT('\n'));
+    _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
     if (__t1 != __first)
         __parse_basic_reg_exp(__first, __t1);
     else
@@ -4504,7 +4504,7 @@ basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
         ++__first;
     while (__first != __last)
     {
-        __t1 = _STD::find(__first, __last, _CharT('\n'));
+        __t1 = _VSTD::find(__first, __last, _CharT('\n'));
         __owns_one_state<_CharT>* __sb = __end_;
         if (__t1 != __first)
             __parse_basic_reg_exp(__first, __t1);
@@ -4525,7 +4525,7 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
                                             _ForwardIterator __last)
 {
     __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __t1 = _STD::find(__first, __last, _CharT('\n'));
+    _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
     if (__t1 != __first)
         __parse_extended_reg_exp(__first, __t1);
     else
@@ -4535,7 +4535,7 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
         ++__first;
     while (__first != __last)
     {
-        __t1 = _STD::find(__first, __last, _CharT('\n'));
+        __t1 = _VSTD::find(__first, __last, _CharT('\n'));
         __owns_one_state<_CharT>* __sb = __end_;
         if (__t1 != __first)
             __parse_extended_reg_exp(__first, __t1);
@@ -4732,7 +4732,7 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     difference_type length() const
-        {return matched ? _STD::distance(this->first, this->second) : 0;}
+        {return matched ? _VSTD::distance(this->first, this->second) : 0;}
     _LIBCPP_INLINE_VISIBILITY
     string_type str() const
         {return matched ? string_type(this->first, this->second) : string_type();}
@@ -5188,7 +5188,7 @@ public:
         {return (*this)[__sub].length();}
     _LIBCPP_INLINE_VISIBILITY
     difference_type position(size_type __sub = 0) const
-        {return _STD::distance(__position_start_, (*this)[__sub].first);}
+        {return _VSTD::distance(__position_start_, (*this)[__sub].first);}
     _LIBCPP_INLINE_VISIBILITY
     string_type str(size_type __sub = 0) const
         {return (*this)[__sub].str();}
@@ -5260,18 +5260,18 @@ public:
         __matches_.resize(__m.size());
         for (size_type __i = 0; __i < __matches_.size(); ++__i)
         {
-            __matches_[__i].first = _STD::next(__f, _STD::distance(__mf, __m[__i].first));
-            __matches_[__i].second = _STD::next(__f, _STD::distance(__mf, __m[__i].second));
+            __matches_[__i].first = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].first));
+            __matches_[__i].second = _VSTD::next(__f, _VSTD::distance(__mf, __m[__i].second));
             __matches_[__i].matched = __m[__i].matched;
         }
         __unmatched_.first   = __l;
         __unmatched_.second  = __l;
         __unmatched_.matched = false;
-        __prefix_.first = _STD::next(__f, _STD::distance(__mf, __m.prefix().first));
-        __prefix_.second = _STD::next(__f, _STD::distance(__mf, __m.prefix().second));
+        __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
+        __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
         __prefix_.matched = __m.prefix().matched;
-        __suffix_.first = _STD::next(__f, _STD::distance(__mf, __m.suffix().first));
-        __suffix_.second = _STD::next(__f, _STD::distance(__mf, __m.suffix().second));
+        __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
+        __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
         __suffix_.matched = __m.suffix().matched;
         if (!__no_update_pos)
             __position_start_ = __prefix_.first;
@@ -5342,7 +5342,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
         for (; __fmt_first != __fmt_last; ++__fmt_first)
         {
             if (*__fmt_first == '&')
-                __out = _STD::copy(__matches_[0].first, __matches_[0].second,
+                __out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
                                    __out);
             else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
             {
@@ -5350,7 +5350,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
                 if ('0' <= *__fmt_first && *__fmt_first <= '9')
                 {
                     size_t __i = *__fmt_first - '0';
-                    __out = _STD::copy(__matches_[__i].first,
+                    __out = _VSTD::copy(__matches_[__i].first,
                                        __matches_[__i].second, __out);
                 }
                 else
@@ -5380,16 +5380,16 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
                     break;
                 case '&':
                     ++__fmt_first;
-                    __out = _STD::copy(__matches_[0].first, __matches_[0].second,
+                    __out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
                                        __out);
                     break;
                 case '`':
                     ++__fmt_first;
-                    __out = _STD::copy(__prefix_.first, __prefix_.second, __out);
+                    __out = _VSTD::copy(__prefix_.first, __prefix_.second, __out);
                     break;
                 case '\'':
                     ++__fmt_first;
-                    __out = _STD::copy(__suffix_.first, __suffix_.second, __out);
+                    __out = _VSTD::copy(__suffix_.first, __suffix_.second, __out);
                     break;
                 default:
                     if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
@@ -5402,7 +5402,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
                             ++__fmt_first;
                             __i = 10 * __i + *__fmt_first - '0';
                         }
-                        __out = _STD::copy(__matches_[__i].first,
+                        __out = _VSTD::copy(__matches_[__i].first,
                                            __matches_[__i].second, __out);
                     }
                     else
@@ -5427,7 +5427,7 @@ template <class _BidirectionalIterator, class _Allocator>
 void
 match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
 {
-    using _STD::swap;
+    using _VSTD::swap;
     swap(__matches_, __m.__matches_);
     swap(__unmatched_, __m.__unmatched_);
     swap(__prefix_, __m.__prefix_);
@@ -5485,7 +5485,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
 {
     vector<__state> __states;
     ptrdiff_t __j = 0;
-    ptrdiff_t _N = _STD::distance(__first, __last);
+    ptrdiff_t _N = _VSTD::distance(__first, __last);
     __node* __st = __start_.get();
     if (__st)
     {
@@ -5509,7 +5509,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
             {
             case __state::__end_state:
                 __m.__matches_[0].first = __first;
-                __m.__matches_[0].second = _STD::next(__first, __s.__current_ - __first);
+                __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
                 __m.__matches_[0].matched = true;
                 for (unsigned __i = 0; __i < __s.__sub_matches_.size(); ++__i)
                     __m.__matches_[__i+1] = __s.__sub_matches_[__i];
@@ -5523,7 +5523,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
                 __state __snext = __s;
                 __s.__node_->__exec_split(true, __s);
                 __snext.__node_->__exec_split(false, __snext);
-                __states.push_back(_STD::move(__snext));
+                __states.push_back(_VSTD::move(__snext));
                 }
                 break;
             case __state::__reject:
@@ -5551,7 +5551,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
 {
     deque<__state> __states;
     ptrdiff_t __highest_j = 0;
-    ptrdiff_t _N = _STD::distance(__first, __last);
+    ptrdiff_t _N = _VSTD::distance(__first, __last);
     __node* __st = __start_.get();
     if (__st)
     {
@@ -5584,7 +5584,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
             case __state::__consume_input:
                 break;
             case __state::__accept_and_consume:
-                __states.push_front(_STD::move(__s));
+                __states.push_front(_VSTD::move(__s));
                 __states.pop_back();
                 break;
             case __state::__repeat:
@@ -5595,7 +5595,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
                 __state __snext = __s;
                 __s.__node_->__exec_split(true, __s);
                 __snext.__node_->__exec_split(false, __snext);
-                __states.push_back(_STD::move(__snext));
+                __states.push_back(_VSTD::move(__snext));
                 }
                 break;
             case __state::__reject:
@@ -5611,7 +5611,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
         if (__matched)
         {
             __m.__matches_[0].first = __first;
-            __m.__matches_[0].second = _STD::next(__first, __highest_j);
+            __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
             __m.__matches_[0].matched = true;
             return true;
         }
@@ -5631,7 +5631,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
     __state __best_state;
     ptrdiff_t __j = 0;
     ptrdiff_t __highest_j = 0;
-    ptrdiff_t _N = _STD::distance(__first, __last);
+    ptrdiff_t _N = _VSTD::distance(__first, __last);
     __node* __st = __start_.get();
     if (__st)
     {
@@ -5678,7 +5678,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
                 __state __snext = __s;
                 __s.__node_->__exec_split(true, __s);
                 __snext.__node_->__exec_split(false, __snext);
-                __states.push_back(_STD::move(__snext));
+                __states.push_back(_VSTD::move(__snext));
                 }
                 break;
             case __state::__reject:
@@ -5694,7 +5694,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
         if (__matched)
         {
             __m.__matches_[0].first = __first;
-            __m.__matches_[0].second = _STD::next(__first, __highest_j);
+            __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
             __m.__matches_[0].matched = true;
             for (unsigned __i = 0; __i < __best_state.__sub_matches_.size(); ++__i)
                 __m.__matches_[__i+1] = __best_state.__sub_matches_[__i];
@@ -5824,7 +5824,7 @@ regex_search(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<const _CharT*> __m;
-    return _STD::regex_search(__str, __m, __e, __flags);
+    return _VSTD::regex_search(__str, __m, __e, __flags);
 }
 
 template <class _ST, class _SA, class _CharT, class _Traits>
@@ -5861,7 +5861,7 @@ regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    bool __r = _STD::regex_search(__first, __last, __m, __e,
+    bool __r = _VSTD::regex_search(__first, __last, __m, __e,
                             __flags | regex_constants::match_continuous);
     if (__r)
     {
@@ -5880,7 +5880,7 @@ regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     match_results<_BidirectionalIterator> __m;
-    return _STD::regex_match(__first, __last, __m, __e, __flags);
+    return _VSTD::regex_match(__first, __last, __m, __e, __flags);
 }
 
 template <class _CharT, class _Allocator, class _Traits>
@@ -5890,7 +5890,7 @@ regex_match(const _CharT* __str, match_results<const _CharT*, _Allocator>& __m,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _STD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
+    return _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
 }
 
 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
@@ -5901,7 +5901,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _STD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
+    return _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
 }
 
 template <class _CharT, class _Traits>
@@ -5910,7 +5910,7 @@ bool
 regex_match(const _CharT* __str, const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _STD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
+    return _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
 }
 
 template <class _ST, class _SA, class _CharT, class _Traits>
@@ -5920,7 +5920,7 @@ regex_match(const basic_string<_CharT, _ST, _SA>& __s,
             const basic_regex<_CharT, _Traits>& __e,
             regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _STD::regex_match(__s.begin(), __s.end(), __e, __flags);
+    return _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
 }
 
 // regex_iterator
@@ -5985,7 +5985,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
       __pregex_(&__re),
       __flags_(__m)
 {
-    _STD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
+    _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
 }
 
 template <class _BidirectionalIterator, class _CharT, class _Traits>
@@ -6017,7 +6017,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
             __match_ = value_type();
             return *this;
         }
-        else if (_STD::regex_search(__start, __end_, __match_, *__pregex_,
+        else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
                                     __flags_ | regex_constants::match_not_null |
                                     regex_constants::match_continuous))
             return *this;
@@ -6025,7 +6025,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
             ++__start;
     }
     __flags_ |= regex_constants::match_prev_avail;
-    if (!_STD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
+    if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
         __match_ = value_type();
     return *this;
 }
@@ -6267,7 +6267,7 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
         }
         else
         {
-            if (_STD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
+            if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
                 && __prev->suffix().length() != 0)
             {
                 __suffix_.matched = true;
@@ -6303,7 +6303,7 @@ regex_replace(_OutputIterator __out,
     if (__i == __eof)
     {
         if (!(__flags & regex_constants::format_no_copy))
-            __out = _STD::copy(__first, __last, __out);
+            __out = _VSTD::copy(__first, __last, __out);
     }
     else
     {
@@ -6311,14 +6311,14 @@ regex_replace(_OutputIterator __out,
         for (size_t __len = char_traits<_CharT>::length(__fmt); __i != __eof; ++__i)
         {
             if (!(__flags & regex_constants::format_no_copy))
-                __out = _STD::copy(__i->prefix().first, __i->prefix().second, __out);
+                __out = _VSTD::copy(__i->prefix().first, __i->prefix().second, __out);
             __out = __i->format(__out, __fmt, __fmt + __len, __flags);
             __lm = __i->suffix();
             if (__flags & regex_constants::format_first_only)
                 break;
         }
         if (!(__flags & regex_constants::format_no_copy))
-            __out = _STD::copy(__lm.first, __lm.second, __out);
+            __out = _VSTD::copy(__lm.first, __lm.second, __out);
     }
     return __out;
 }
@@ -6333,7 +6333,7 @@ regex_replace(_OutputIterator __out,
               const basic_string<_CharT, _ST, _SA>& __fmt,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
-    return _STD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
+    return _VSTD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
 }
 
 template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
@@ -6346,7 +6346,7 @@ regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
-    _STD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
+    _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt.c_str(), __flags);
     return __r;
 }
@@ -6359,7 +6359,7 @@ regex_replace(const basic_string<_CharT, _ST, _SA>& __s,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT, _ST, _SA> __r;
-    _STD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
+    _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                         __fmt, __flags);
     return __r;
 }
@@ -6373,7 +6373,7 @@ regex_replace(const _CharT* __s,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __r;
-    _STD::regex_replace(back_inserter(__r), __s,
+    _VSTD::regex_replace(back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt.c_str(), __flags);
     return __r;
@@ -6388,7 +6388,7 @@ regex_replace(const _CharT* __s,
               regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
     basic_string<_CharT> __r;
-    _STD::regex_replace(back_inserter(__r), __s,
+    _VSTD::regex_replace(back_inserter(__r), __s,
                         __s + char_traits<_CharT>::length(__s), __e,
                         __fmt, __flags);
     return __r;

include/scoped_allocator

@@ -194,7 +194,7 @@ protected:
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(_OuterA2&& __outerAlloc,
                                    const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
+            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)),
               __inner_(__innerAllocs...) {}
 
     template <class _OuterA2,
@@ -214,8 +214,8 @@ protected:
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(
             __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-            : outer_allocator_type(_STD::move(__other.outer_allocator())),
-              __inner_(_STD::move(__other.inner_allocator())) {}
+            : outer_allocator_type(_VSTD::move(__other.outer_allocator())),
+              __inner_(_VSTD::move(__other.inner_allocator())) {}
 
     template <class _OuterA2,
               class = typename enable_if<
@@ -224,7 +224,7 @@ protected:
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(_OuterA2&& __o,
                                    const inner_allocator_type& __i) _NOEXCEPT
-            : outer_allocator_type(_STD::forward<_OuterA2>(__o)),
+            : outer_allocator_type(_VSTD::forward<_OuterA2>(__o)),
               __inner_(__i)
         {
         }
@@ -274,7 +274,7 @@ protected:
                       >::type>
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
-            : outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}
+            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
 
     template <class _OuterA2,
               class = typename enable_if<
@@ -292,7 +292,7 @@ protected:
         _LIBCPP_INLINE_VISIBILITY
         __scoped_allocator_storage(
             __scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
-            : outer_allocator_type(_STD::move(__other.outer_allocator())) {}
+            : outer_allocator_type(_VSTD::move(__other.outer_allocator())) {}
 
     _LIBCPP_INLINE_VISIBILITY
     inner_allocator_type& inner_allocator() _NOEXCEPT
@@ -354,7 +354,7 @@ struct __outermost<_Alloc, true>
 {
     typedef typename remove_reference
                      <
-                        decltype(_STD::declval<_Alloc>().outer_allocator())
+                        decltype(_VSTD::declval<_Alloc>().outer_allocator())
                      >::type                                    _OuterAlloc;
     typedef typename __outermost<_OuterAlloc>::type             type;
     _LIBCPP_INLINE_VISIBILITY
@@ -414,7 +414,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
                                  const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
+            : base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
     // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
     template <class _OuterA2,
               class = typename enable_if<
@@ -431,7 +431,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         scoped_allocator_adaptor(
             scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-                : base(_STD::move(__other)) {}
+                : base(_VSTD::move(__other)) {}
 
     // ~scoped_allocator_adaptor() = default;
 
@@ -471,7 +471,7 @@ public:
         _LIBCPP_INLINE_VISIBILITY
         void construct(_Tp* __p, _Args&& ...__args)
             {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
-                         __p, _STD::forward<_Args>(__args)...);}
+                         __p, _VSTD::forward<_Args>(__args)...);}
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
         void destroy(_Tp* __p)
@@ -494,7 +494,7 @@ private:
     _LIBCPP_INLINE_VISIBILITY
     scoped_allocator_adaptor(_OuterA2&& __o,
                              const inner_allocator_type& __i) _NOEXCEPT
-        : base(_STD::forward<_OuterA2>(__o), __i) {}
+        : base(_VSTD::forward<_OuterA2>(__o), __i) {}
 
     template <class _Tp, class... _Args>
         _LIBCPP_INLINE_VISIBILITY
@@ -505,7 +505,7 @@ private:
                 (
                     _OM()(outer_allocator()),
                     __p,
-                    _STD::forward<_Args>(__args)...
+                    _VSTD::forward<_Args>(__args)...
                 );
             }
 
@@ -520,7 +520,7 @@ private:
                     __p,
                     allocator_arg,
                     inner_allocator(),
-                    _STD::forward<_Args>(__args)...
+                    _VSTD::forward<_Args>(__args)...
                 );
             }
 
@@ -533,7 +533,7 @@ private:
                 (
                     _OM()(outer_allocator()),
                     __p,
-                    _STD::forward<_Args>(__args)...,
+                    _VSTD::forward<_Args>(__args)...,
                     inner_allocator()
                 );
             }

include/set

@@ -370,8 +370,8 @@ public:
     typedef typename __base::difference_type       difference_type;
     typedef typename __base::const_iterator        iterator;
     typedef typename __base::const_iterator        const_iterator;
-    typedef _STD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     explicit set(const value_compare& __comp = value_compare())
@@ -408,11 +408,18 @@ public:
             insert(__s.begin(), __s.end());
         }
 
+    _LIBCPP_INLINE_VISIBILITY
+    set& operator=(const set& __s)
+        {
+            __tree_ = __s.__tree_;
+            return *this;
+        }
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     set(set&& __s)
         _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_STD::move(__s.__tree_)) {}
+        : __tree_(_VSTD::move(__s.__tree_)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
@@ -457,7 +464,7 @@ public:
     set& operator=(set&& __s)
         _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
         {
-            __tree_ = _STD::move(__s.__tree_);
+            __tree_ = _VSTD::move(__s.__tree_);
             return *this;
         }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -505,11 +512,11 @@ public:
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_Args&&... __args)
-            {return __tree_.__emplace_unique(_STD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __tree_.__emplace_hint_unique(__p, _STD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);}
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,bool> insert(const value_type& __v)
@@ -517,7 +524,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator,bool> insert(value_type&& __v)
-        {return __tree_.__insert_unique(_STD::move(__v));}
+        {return __tree_.__insert_unique(_VSTD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __v)
@@ -525,7 +532,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_unique(__p, _STD::move(__v));}
+        {return __tree_.__insert_unique(__p, _VSTD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
@@ -593,13 +600,13 @@ public:
 
 template <class _Key, class _Compare, class _Allocator>
 set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
-    : __tree_(_STD::move(__s.__tree_), __a)
+    : __tree_(_VSTD::move(__s.__tree_), __a)
 {
     if (__a != __s.get_allocator())
     {
         const_iterator __e = cend();
         while (!__s.empty())
-            insert(__e, _STD::move(__s.__tree_.remove(__s.begin())->__value_));
+            insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
     }
 }
 
@@ -611,7 +618,7 @@ bool
 operator==(const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
 {
-    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Key, class _Compare, class _Allocator>
@@ -620,7 +627,7 @@ bool
 operator< (const set<_Key, _Compare, _Allocator>& __x,
            const set<_Key, _Compare, _Allocator>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Compare, class _Allocator>
@@ -698,8 +705,8 @@ public:
     typedef typename __base::difference_type       difference_type;
     typedef typename __base::const_iterator        iterator;
     typedef typename __base::const_iterator        const_iterator;
-    typedef _STD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
 
     // construct/copy/destroy:
     _LIBCPP_INLINE_VISIBILITY
@@ -738,11 +745,18 @@ public:
             insert(__s.begin(), __s.end());
         }
 
+    _LIBCPP_INLINE_VISIBILITY
+    multiset& operator=(const multiset& __s)
+        {
+            __tree_ = __s.__tree_;
+            return *this;
+        }
+
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     multiset(multiset&& __s)
         _NOEXCEPT_(is_nothrow_move_constructible<__base>::value)
-        : __tree_(_STD::move(__s.__tree_)) {}
+        : __tree_(_VSTD::move(__s.__tree_)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     explicit multiset(const allocator_type& __a)
@@ -784,7 +798,7 @@ public:
     multiset& operator=(multiset&& __s)
         _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
         {
-            __tree_ = _STD::move(__s.__tree_);
+            __tree_ = _VSTD::move(__s.__tree_);
             return *this;
         }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -832,11 +846,11 @@ public:
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_Args&&... __args)
-            {return __tree_.__emplace_multi(_STD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __tree_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const value_type& __v)
@@ -844,7 +858,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(value_type&& __v)
-        {return __tree_.__insert_multi(_STD::move(__v));}
+        {return __tree_.__insert_multi(_VSTD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __v)
@@ -852,7 +866,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_multi(_STD::move(__v));}
+        {return __tree_.__insert_multi(_VSTD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
         _LIBCPP_INLINE_VISIBILITY
@@ -920,13 +934,13 @@ public:
 
 template <class _Key, class _Compare, class _Allocator>
 multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
-    : __tree_(_STD::move(__s.__tree_), __a)
+    : __tree_(_VSTD::move(__s.__tree_), __a)
 {
     if (__a != __s.get_allocator())
     {
         const_iterator __e = cend();
         while (!__s.empty())
-            insert(__e, _STD::move(__s.__tree_.remove(__s.begin())->__value_));
+            insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
     }
 }
 
@@ -938,7 +952,7 @@ bool
 operator==(const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
 {
-    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Key, class _Compare, class _Allocator>
@@ -947,7 +961,7 @@ bool
 operator< (const multiset<_Key, _Compare, _Allocator>& __x,
            const multiset<_Key, _Compare, _Allocator>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Key, class _Compare, class _Allocator>

include/sstream

@@ -261,7 +261,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::basic_stringbuf(basic_stringbuf&&
     ptrdiff_t __nout = __rhs.pptr()  - __rhs.pbase();
     ptrdiff_t __eout = __rhs.epptr() - __rhs.pbase();
     ptrdiff_t __hm   = __rhs.__hm_   - __rhs.pbase();
-    __str_ = _STD::move(__rhs.__str_);
+    __str_ = _VSTD::move(__rhs.__str_);
     char_type* __p = const_cast<char_type*>(__str_.data());
     this->setg(__p, __p + __ninp, __p + __einp);
     this->setp(__p, __p + __eout);
@@ -284,7 +284,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::operator=(basic_stringbuf&& __rhs)
     ptrdiff_t __eout = __rhs.epptr() - __rhs.pbase();
     ptrdiff_t __hm   = __rhs.__hm_   - __rhs.pbase();
     __mode_ = __rhs.__mode_;
-    __str_ = _STD::move(__rhs.__str_);
+    __str_ = _VSTD::move(__rhs.__str_);
     char_type* __p = const_cast<char_type*>(__str_.data());
     this->setg(__p, __p + __ninp, __p + __einp);
     this->setp(__p, __p + __eout);
@@ -314,7 +314,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::swap(basic_stringbuf& __rhs)
     ptrdiff_t __lnout = this->pptr()  - this->pbase();
     ptrdiff_t __leout = this->epptr() - this->pbase();
     ptrdiff_t __lhm   = this->__hm_   - this->pbase();
-    _STD::swap(__mode_, __rhs.__mode_);
+    _VSTD::swap(__mode_, __rhs.__mode_);
     __str_.swap(__rhs.__str_);
     char_type* __p = const_cast<char_type*>(__str_.data());
     this->setg(__p, __p + __rninp, __p + __reinp);
@@ -451,7 +451,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
             }
 #endif  // _LIBCPP_NO_EXCEPTIONS
         }
-        __hm_ = _STD::max(this->pptr() + 1, __hm_);
+        __hm_ = _VSTD::max(this->pptr() + 1, __hm_);
         if (__mode_ & ios_base::in)
         {
             char_type* __p = const_cast<char_type*>(__str_.data());
@@ -582,8 +582,8 @@ basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(const stri
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_istringstream<_CharT, _Traits, _Allocator>::basic_istringstream(basic_istringstream&& __rhs)
-    : basic_istream<_CharT, _Traits>(_STD::move(__rhs)),
-      __sb_(_STD::move(__rhs.__sb_))
+    : basic_istream<_CharT, _Traits>(_VSTD::move(__rhs)),
+      __sb_(_VSTD::move(__rhs.__sb_))
 {
     basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
 }
@@ -592,8 +592,8 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_istringstream<_CharT, _Traits, _Allocator>&
 basic_istringstream<_CharT, _Traits, _Allocator>::operator=(basic_istringstream&& __rhs)
 {
-    basic_istream<char_type, traits_type>::operator=(_STD::move(__rhs));
-    __sb_ = _STD::move(__rhs.__sb_);
+    basic_istream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
+    __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
@@ -701,8 +701,8 @@ basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(const stri
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_ostringstream<_CharT, _Traits, _Allocator>::basic_ostringstream(basic_ostringstream&& __rhs)
-    : basic_ostream<_CharT, _Traits>(_STD::move(__rhs)),
-      __sb_(_STD::move(__rhs.__sb_))
+    : basic_ostream<_CharT, _Traits>(_VSTD::move(__rhs)),
+      __sb_(_VSTD::move(__rhs.__sb_))
 {
     basic_ostream<_CharT, _Traits>::set_rdbuf(&__sb_);
 }
@@ -711,8 +711,8 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_ostringstream<_CharT, _Traits, _Allocator>&
 basic_ostringstream<_CharT, _Traits, _Allocator>::operator=(basic_ostringstream&& __rhs)
 {
-    basic_ostream<char_type, traits_type>::operator=(_STD::move(__rhs));
-    __sb_ = _STD::move(__rhs.__sb_);
+    basic_ostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
+    __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 
@@ -820,8 +820,8 @@ basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(const string
 template <class _CharT, class _Traits, class _Allocator>
 inline _LIBCPP_INLINE_VISIBILITY
 basic_stringstream<_CharT, _Traits, _Allocator>::basic_stringstream(basic_stringstream&& __rhs)
-    : basic_iostream<_CharT, _Traits>(_STD::move(__rhs)),
-      __sb_(_STD::move(__rhs.__sb_))
+    : basic_iostream<_CharT, _Traits>(_VSTD::move(__rhs)),
+      __sb_(_VSTD::move(__rhs.__sb_))
 {
     basic_istream<_CharT, _Traits>::set_rdbuf(&__sb_);
 }
@@ -830,8 +830,8 @@ template <class _CharT, class _Traits, class _Allocator>
 basic_stringstream<_CharT, _Traits, _Allocator>&
 basic_stringstream<_CharT, _Traits, _Allocator>::operator=(basic_stringstream&& __rhs)
 {
-    basic_iostream<char_type, traits_type>::operator=(_STD::move(__rhs));
-    __sb_ = _STD::move(__rhs.__sb_);
+    basic_iostream<char_type, traits_type>::operator=(_VSTD::move(__rhs));
+    __sb_ = _VSTD::move(__rhs.__sb_);
     return *this;
 }
 

include/stack

@@ -125,7 +125,7 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     stack(stack&& __q)
         _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_STD::move(__q.c)) {}
+        : c(_VSTD::move(__q.c)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
@@ -135,14 +135,14 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     stack& operator=(stack&& __q)
         _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _STD::move(__q.c); return *this;}
+        {c = _VSTD::move(__q.c); return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
     explicit stack(const container_type& __c) : c(__c) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    explicit stack(container_type&& __c) : c(_STD::move(__c)) {}
+    explicit stack(container_type&& __c) : c(_VSTD::move(__c)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
@@ -168,13 +168,13 @@ public:
         stack(container_type&& __c, const _Alloc& __a,
               typename enable_if<uses_allocator<container_type,
                                                 _Alloc>::value>::type* = 0)
-            : c(_STD::move(__c), __a) {}
+            : c(_VSTD::move(__c), __a) {}
     template <class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         stack(stack&& __s, const _Alloc& __a,
               typename enable_if<uses_allocator<container_type,
                                                 _Alloc>::value>::type* = 0)
-            : c(_STD::move(__s.c), __a) {}
+            : c(_VSTD::move(__s.c), __a) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
@@ -190,12 +190,12 @@ public:
     void push(const value_type& __v) {c.push_back(__v);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    void push(value_type&& __v) {c.push_back(_STD::move(__v));}
+    void push(value_type&& __v) {c.push_back(_VSTD::move(__v));}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         void emplace(_Args&&... __args)
-        {c.emplace_back(_STD::forward<_Args>(__args)...);}
+        {c.emplace_back(_VSTD::forward<_Args>(__args)...);}
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
@@ -205,7 +205,7 @@ public:
     void swap(stack& __s)
         _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
     {
-        using _STD::swap;
+        using _VSTD::swap;
         swap(c, __s.c);
     }
 

include/streambuf

@@ -399,13 +399,13 @@ template <class _CharT, class _Traits>
 void
 basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
 {
-    _STD::swap(__loc_, __sb.__loc_);
-    _STD::swap(__binp_, __sb.__binp_);
-    _STD::swap(__ninp_, __sb.__ninp_);
-    _STD::swap(__einp_, __sb.__einp_);
-    _STD::swap(__bout_, __sb.__bout_);
-    _STD::swap(__nout_, __sb.__nout_);
-    _STD::swap(__eout_, __sb.__eout_);
+    _VSTD::swap(__loc_, __sb.__loc_);
+    _VSTD::swap(__binp_, __sb.__binp_);
+    _VSTD::swap(__ninp_, __sb.__ninp_);
+    _VSTD::swap(__einp_, __sb.__einp_);
+    _VSTD::swap(__bout_, __sb.__bout_);
+    _VSTD::swap(__nout_, __sb.__nout_);
+    _VSTD::swap(__eout_, __sb.__eout_);
 }
 
 template <class _CharT, class _Traits>

include/string

@@ -972,23 +972,24 @@ char_traits<char32_t>::assign(char_type* __s, size_t __n, char_type __a)
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-operator+(const basic_string<_CharT, _Traits, _Allocator>&, const basic_string<_CharT, _Traits, _Allocator>&);
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __x,
+          const basic_string<_CharT, _Traits, _Allocator>& __y);
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-operator+(const _CharT*, const basic_string<_CharT,_Traits,_Allocator>&);
+operator+(const _CharT* __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-operator+(_CharT, const basic_string<_CharT,_Traits,_Allocator>&);
+operator+(_CharT __x, const basic_string<_CharT,_Traits,_Allocator>& __y);
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-operator+(const basic_string<_CharT, _Traits, _Allocator>&, const _CharT*);
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, const _CharT* __y);
 
 template<class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>
-operator+(const basic_string<_CharT, _Traits, _Allocator>&, _CharT);
+operator+(const basic_string<_CharT, _Traits, _Allocator>& __x, _CharT __y);
 
 template <bool>
 class __basic_string_common
@@ -1051,8 +1052,8 @@ public:
     typedef __wrap_iter<pointer>                         iterator;
     typedef __wrap_iter<const_pointer>                   const_iterator;
 #endif  // defined(_LIBCPP_RAW_ITERATORS)
-    typedef _STD::reverse_iterator<iterator>             reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator>       const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>             reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>       const_reverse_iterator;
 
 private:
     struct __long
@@ -1278,7 +1279,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     basic_string& assign(basic_string&& str)
-        {*this = _STD::move(str); return *this;}
+        {*this = _VSTD::move(str); return *this;}
 #endif
     basic_string& assign(const basic_string& __str, size_type __pos, size_type __n);
     basic_string& assign(const_pointer __s, size_type __n);
@@ -1587,7 +1588,7 @@ private:
     static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
     _LIBCPP_INLINE_VISIBILITY
@@ -1789,7 +1790,7 @@ template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-    : __r_(_STD::move(__str.__r_))
+    : __r_(_VSTD::move(__str.__r_))
 {
     __str.__zero();
 #ifdef _LIBCPP_DEBUG
@@ -1861,7 +1862,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __st
     size_type __str_sz = __str.size();
     if (__pos > __str_sz)
         this->__throw_out_of_range();
-    __init(__str.data() + __pos, _STD::min(__n, __str_sz - __pos));
+    __init(__str.data() + __pos, _VSTD::min(__n, __str_sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -1901,7 +1902,7 @@ typename enable_if
 >::type
 basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _ForwardIterator __last)
 {
-    size_type __sz = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __sz = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__sz > max_size())
         this->__throw_length_error();
     pointer __p;
@@ -1975,7 +1976,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
         this->__throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
-                          __recommend(_STD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
+                          __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
     pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
     __invalidate_all_iterators();
@@ -2005,7 +2006,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
         this->__throw_length_error();
     pointer __old_p = __get_pointer();
     size_type __cap = __old_cap < __ms / 2 - __alignment ?
-                          __recommend(_STD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
+                          __recommend(_VSTD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                           __ms - 1;
     pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
     __invalidate_all_iterators();
@@ -2119,7 +2120,7 @@ basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, tr
 {
     clear();
     shrink_to_fit();
-    __r_ = _STD::move(__str.__r_);
+    __r_ = _VSTD::move(__str.__r_);
     __str.__zero();
 }
 
@@ -2161,7 +2162,7 @@ typename enable_if
 >::type
 basic_string<_CharT, _Traits, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     size_type __cap = capacity();
     if (__cap < __n)
     {
@@ -2193,7 +2194,7 @@ basic_string<_CharT, _Traits, _Allocator>::assign(const basic_string& __str, siz
     size_type __sz = __str.size();
     if (__pos > __sz)
         this->__throw_out_of_range();
-    return assign(__str.data() + __pos, _STD::min(__n, __sz - __pos));
+    return assign(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2292,7 +2293,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(_ForwardIterator __first, _For
 {
     size_type __sz = size();
     size_type __cap = capacity();
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
         if (__cap - __sz < __n)
@@ -2321,7 +2322,7 @@ basic_string<_CharT, _Traits, _Allocator>::append(const basic_string& __str, siz
     size_type __sz = __str.size();
     if (__pos > __sz)
         this->__throw_out_of_range();
-    return append(__str.data() + __pos, _STD::min(__n, __sz - __pos));
+    return append(__str.data() + __pos, _VSTD::min(__n, __sz - __pos));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2416,7 +2417,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _InputIt
     for (; __first != __last; ++__first)
         push_back(*__first);
     pointer __p = __get_pointer();
-    _STD::rotate(__p + __ip, __p + __old_sz, __p + size());
+    _VSTD::rotate(__p + __ip, __p + __old_sz, __p + size());
     return iterator(__p + __ip);
 }
 
@@ -2432,7 +2433,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(const_iterator __pos, _Forward
     size_type __ip = static_cast<size_type>(__pos - begin());
     size_type __sz = size();
     size_type __cap = capacity();
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n)
     {
         pointer __p;
@@ -2473,7 +2474,7 @@ basic_string<_CharT, _Traits, _Allocator>::insert(size_type __pos1, const basic_
     size_type __str_sz = __str.size();
     if (__pos2 > __str_sz)
         this->__throw_out_of_range();
-    return insert(__pos1, __str.data() + __pos2, _STD::min(__n, __str_sz - __pos2));
+    return insert(__pos1, __str.data() + __pos2, _VSTD::min(__n, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2534,7 +2535,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
-    __n1 = _STD::min(__n1, __sz - __pos);
+    __n1 = _VSTD::min(__n1, __sz - __pos);
     size_type __cap = capacity();
     if (__cap - __sz + __n1 >= __n2)
     {
@@ -2585,7 +2586,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
-    __n1 = _STD::min(__n1, __sz - __pos);
+    __n1 = _VSTD::min(__n1, __sz - __pos);
     size_type __cap = capacity();
     pointer __p;
     if (__cap - __sz + __n1 >= __n2)
@@ -2655,7 +2656,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos1, size_type _
     size_type __str_sz = __str.size();
     if (__pos2 > __str_sz)
         this->__throw_out_of_range();
-    return replace(__pos1, __n1, __str.data() + __pos2, _STD::min(__n2, __str_sz - __pos2));
+    return replace(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2, __str_sz - __pos2));
 }
 
 template <class _CharT, class _Traits, class _Allocator>
@@ -2713,7 +2714,7 @@ basic_string<_CharT, _Traits, _Allocator>::erase(size_type __pos, size_type __n)
     if (__n)
     {
         pointer __p = __get_pointer();
-        __n = _STD::min(__n, __sz - __pos);
+        __n = _VSTD::min(__n, __sz - __pos);
         size_type __n_move = __sz - __pos - __n;
         if (__n_move != 0)
             traits_type::move(__p + __pos, __p + __pos + __n, __n_move);
@@ -2839,7 +2840,7 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
         this->__throw_length_error();
     size_type __cap = capacity();
     size_type __sz = size();
-    __res_arg = _STD::max(__res_arg, __sz);
+    __res_arg = _VSTD::max(__res_arg, __sz);
     __res_arg = __recommend(__res_arg);
     if (__res_arg != __cap)
     {
@@ -2984,7 +2985,7 @@ basic_string<_CharT, _Traits, _Allocator>::copy(pointer __s, size_type __n, size
     size_type __sz = size();
     if (__pos > __sz)
         this->__throw_out_of_range();
-    size_type __rlen = _STD::min(__n, __sz - __pos);
+    size_type __rlen = _VSTD::min(__n, __sz - __pos);
     traits_type::copy(__s, data() + __pos, __rlen);
     return __rlen;
 }
@@ -3004,7 +3005,7 @@ basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<allocator_type>::value)
 {
-    _STD::swap(__r_.first(), __str.__r_.first());
+    _VSTD::swap(__r_.first(), __str.__r_.first());
     __swap_alloc(__alloc(), __str.__alloc());
 #ifdef _LIBCPP_DEBUG
     __invalidate_all_iterators();
@@ -3038,7 +3039,7 @@ basic_string<_CharT, _Traits, _Allocator>::find(const_pointer __s,
     if (__n == 0)
         return __pos;
     const_pointer __p = data();
-    const_pointer __r = _STD::search(__p + __pos, __p + __sz, __s, __s + __n,
+    const_pointer __r = _VSTD::search(__p + __pos, __p + __sz, __s, __s + __n,
                                      __traits_eq<traits_type>());
     if (__r == __p + __sz)
         return npos;
@@ -3093,13 +3094,13 @@ basic_string<_CharT, _Traits, _Allocator>::rfind(const_pointer __s,
     assert(__s != 0);
 #endif
     size_type __sz = size();
-    __pos = _STD::min(__pos, __sz);
+    __pos = _VSTD::min(__pos, __sz);
     if (__n < __sz - __pos)
         __pos += __n;
     else
         __pos = __sz;
     const_pointer __p = data();
-    const_pointer __r = _STD::find_end(__p, __p + __pos, __s, __s + __n,
+    const_pointer __r = _VSTD::find_end(__p, __p + __pos, __s, __s + __n,
                                        __traits_eq<traits_type>());
     if (__n > 0 && __r == __p + __pos)
         return npos;
@@ -3164,7 +3165,7 @@ basic_string<_CharT, _Traits, _Allocator>::find_first_of(const_pointer __s,
     if (__pos >= __sz || __n == 0)
         return npos;
     const_pointer __p = data();
-    const_pointer __r = _STD::find_first_of(__p + __pos, __p + __sz, __s,
+    const_pointer __r = _VSTD::find_first_of(__p + __pos, __p + __sz, __s,
                                             __s + __n, __traits_eq<traits_type>());
     if (__r == __p + __sz)
         return npos;
@@ -3415,7 +3416,7 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
     size_type __sz = __str.size();
     if (__pos2 > __sz)
         this->__throw_out_of_range();
-    return compare(__pos1, __n1, __str.data() + __pos2, _STD::min(__n2,
+    return compare(__pos1, __n1, __str.data() + __pos2, _VSTD::min(__n2,
                                                                   __sz - __pos2));
 }
 
@@ -3454,8 +3455,8 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1,
     size_type __sz = size();
     if (__pos1 > __sz || __n2 == npos)
         this->__throw_out_of_range();
-    size_type __rlen = _STD::min(__n1, __sz - __pos1);
-    int __r = traits_type::compare(data() + __pos1, __s, _STD::min(__rlen, __n2));
+    size_type __rlen = _VSTD::min(__n1, __sz - __pos1);
+    int __r = traits_type::compare(data() + __pos1, __s, _VSTD::min(__rlen, __n2));
     if (__r == 0)
     {
         if (__rlen < __n2)
@@ -3818,7 +3819,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const basic_string<_CharT, _Traits, _Allocator>& __rhs)
 {
-    return _STD::move(__lhs.append(__rhs));
+    return _VSTD::move(__lhs.append(__rhs));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
@@ -3826,7 +3827,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
 {
-    return _STD::move(__rhs.insert(0, __lhs));
+    return _VSTD::move(__rhs.insert(0, __lhs));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
@@ -3834,7 +3835,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, basic_string<_CharT, _Traits, _Allocator>&& __rhs)
 {
-    return _STD::move(__lhs.append(__rhs));
+    return _VSTD::move(__lhs.append(__rhs));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
@@ -3842,7 +3843,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>
 operator+(const _CharT* __lhs , basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 {
-    return _STD::move(__rhs.insert(0, __lhs));
+    return _VSTD::move(__rhs.insert(0, __lhs));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
@@ -3851,7 +3852,7 @@ basic_string<_CharT, _Traits, _Allocator>
 operator+(_CharT __lhs, basic_string<_CharT,_Traits,_Allocator>&& __rhs)
 {
     __rhs.insert(__rhs.begin(), __lhs);
-    return _STD::move(__rhs);
+    return _VSTD::move(__rhs);
 }
 
 template<class _CharT, class _Traits, class _Allocator>
@@ -3859,7 +3860,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, const _CharT* __rhs)
 {
-    return _STD::move(__lhs.append(__rhs));
+    return _VSTD::move(__lhs.append(__rhs));
 }
 
 template<class _CharT, class _Traits, class _Allocator>
@@ -3868,7 +3869,7 @@ basic_string<_CharT, _Traits, _Allocator>
 operator+(basic_string<_CharT, _Traits, _Allocator>&& __lhs, _CharT __rhs)
 {
     __lhs.push_back(__rhs);
-    return _STD::move(__lhs);
+    return _VSTD::move(__lhs);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -3968,54 +3969,6 @@ hash<basic_string<_CharT, _Traits, _Allocator> >::operator()(
 extern template class basic_string<char>;
 extern template class basic_string<wchar_t>;
 
-extern template
-    enable_if<__is_forward_iterator<char const*>::value, void>::type
-    basic_string<char, char_traits<char>, allocator<char> >::
-    __init<char const*>(char const*, char const*);
-
-extern template
-    enable_if<__is_forward_iterator<wchar_t const*>::value, void>::type
-    basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
-    __init<wchar_t const*>(wchar_t const*, wchar_t const*);
-
-extern template
-    enable_if<__is_forward_iterator<char*>::value,
-    basic_string<char, char_traits<char>, allocator<char> >&>::type
-    basic_string<char, char_traits<char>, allocator<char> >::
-    append<char*>(char*, char*);
-
-extern template
-    enable_if<__is_forward_iterator<wchar_t*>::value,
-    basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&>::type
-    basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
-    append<wchar_t*>(wchar_t*, wchar_t*);
-
-extern template
-    enable_if<__is_forward_iterator<char const*>::value,
-    string::iterator>::type
-    string::
-    insert<char const*>(string::const_iterator, char const*, char const*);
-
-extern template
-    enable_if<__is_forward_iterator<wchar_t const*>::value,
-    wstring::iterator>::type
-    wstring::
-    insert<wchar_t const*>(wstring::const_iterator, wchar_t const*, wchar_t const*);
-
-extern template
-    enable_if<__is_input_iterator<char const*>::value, string&>::type
-    string::
-    replace<char const*>(string::const_iterator, string::const_iterator, char const*, char const*);
-
-extern template
-    enable_if<__is_input_iterator<wchar_t const*>::value, wstring&>::type
-    wstring::
-    replace<wchar_t const*>(wstring::const_iterator, wstring::const_iterator, wchar_t const*, wchar_t const*);
-
-extern template
-    enable_if<__is_forward_iterator<wchar_t*>::value, wstring&>::type
-    wstring::assign<wchar_t*>(wchar_t*, wchar_t*);
-
 extern template
     string
     operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);

include/strstream

@@ -150,7 +150,9 @@ public:
     strstreambuf(const unsigned char* __gnext, streamsize __n);
 
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
     strstreambuf(strstreambuf&& __rhs);
+    _LIBCPP_INLINE_VISIBILITY
     strstreambuf& operator=(strstreambuf&& __rhs);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
@@ -187,6 +189,43 @@ private:
     void __init(char* __gnext, streamsize __n, char* __pbeg);
 };
 
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
+inline _LIBCPP_INLINE_VISIBILITY
+strstreambuf::strstreambuf(strstreambuf&& __rhs)
+    : streambuf(__rhs),
+      __strmode_(__rhs.__strmode_),
+      __alsize_(__rhs.__alsize_),
+      __palloc_(__rhs.__palloc_),
+      __pfree_(__rhs.__pfree_)
+{
+    __rhs.setg(nullptr, nullptr, nullptr);
+    __rhs.setp(nullptr, nullptr);
+}
+
+inline _LIBCPP_INLINE_VISIBILITY
+strstreambuf&
+strstreambuf::operator=(strstreambuf&& __rhs)
+{
+    if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
+    {
+        if (__pfree_)
+            __pfree_(eback());
+        else
+            delete [] eback();
+    }
+    streambuf::operator=(__rhs);
+    __strmode_ = __rhs.__strmode_;
+    __alsize_ = __rhs.__alsize_;
+    __palloc_ = __rhs.__palloc_;
+    __pfree_ = __rhs.__pfree_;
+    __rhs.setg(nullptr, nullptr, nullptr);
+    __rhs.setp(nullptr, nullptr);
+    return *this;
+}
+
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
 class _LIBCPP_VISIBLE istrstream
     : public istream
 {
@@ -207,8 +246,8 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     istrstream(istrstream&& __rhs)
-        : istream(_STD::move(__rhs)),
-          __sb_(_STD::move(__rhs.__sb_))
+        : istream(_VSTD::move(__rhs)),
+          __sb_(_VSTD::move(__rhs.__sb_))
     {
         istream::set_rdbuf(&__sb_);
     }
@@ -216,8 +255,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     istrstream& operator=(istrstream&& __rhs)
     {
-        istream::operator=(_STD::move(__rhs));
-        __sb_ = _STD::move(__rhs.__sb_);
+        istream::operator=(_VSTD::move(__rhs));
+        __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -256,8 +295,8 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     ostrstream(ostrstream&& __rhs)
-        : ostream(_STD::move(__rhs)),
-          __sb_(_STD::move(__rhs.__sb_))
+        : ostream(_VSTD::move(__rhs)),
+          __sb_(_VSTD::move(__rhs.__sb_))
     {
         ostream::set_rdbuf(&__sb_);
     }
@@ -265,8 +304,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     ostrstream& operator=(ostrstream&& __rhs)
     {
-        ostream::operator=(_STD::move(__rhs));
-        __sb_ = _STD::move(__rhs.__sb_);
+        ostream::operator=(_VSTD::move(__rhs));
+        __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -316,8 +355,8 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     strstream(strstream&& __rhs)
-        : iostream(_STD::move(__rhs)),
-          __sb_(_STD::move(__rhs.__sb_))
+        : iostream(_VSTD::move(__rhs)),
+          __sb_(_VSTD::move(__rhs.__sb_))
     {
         iostream::set_rdbuf(&__sb_);
     }
@@ -325,8 +364,8 @@ public:
     _LIBCPP_INLINE_VISIBILITY
     strstream& operator=(strstream&& __rhs)
     {
-        iostream::operator=(_STD::move(__rhs));
-        __sb_ = _STD::move(__rhs.__sb_);
+        iostream::operator=(_VSTD::move(__rhs));
+        __sb_ = _VSTD::move(__rhs.__sb_);
         return *this;
     }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

include/thread

@@ -284,7 +284,7 @@ public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     _LIBCPP_INLINE_VISIBILITY
-    void swap(thread& __t) {_STD::swap(__t_, __t.__t_);}
+    void swap(thread& __t) {_VSTD::swap(__t_, __t.__t_);}
 
     _LIBCPP_INLINE_VISIBILITY
     bool joinable() const {return __t_ != 0;}
@@ -325,7 +325,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 __threaad_execute(tuple<_F, _Args...>& __t, __tuple_indices<_Indices...>)
 {
-    __invoke(_STD::move(_STD::get<0>(__t)), _STD::move(_STD::get<_Indices>(__t))...);
+    __invoke(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
 }
 
 template <class _F>
@@ -345,8 +345,8 @@ template <class _F, class ..._Args,
 thread::thread(_F&& __f, _Args&&... __args)
 {
     typedef tuple<typename decay<_F>::type, typename decay<_Args>::type...> _G;
-    _STD::unique_ptr<_G> __p(new _G(__decay_copy(_STD::forward<_F>(__f)),
-                                __decay_copy(_STD::forward<_Args>(__args))...));
+    _VSTD::unique_ptr<_G> __p(new _G(__decay_copy(_VSTD::forward<_F>(__f)),
+                                __decay_copy(_VSTD::forward<_Args>(__args))...));
     int __ec = pthread_create(&__t_, 0, &__thread_proxy<_G>, __p.get());
     if (__ec == 0)
         __p.release();

include/tuple

@@ -191,7 +191,7 @@ public:
               class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(_Tp&& __t)
-            : value(_STD::forward<_Tp>(__t))
+            : value(_VSTD::forward<_Tp>(__t))
         {static_assert(!is_reference<_Hp>::value ||
                         is_lvalue_reference<_Hp>::value &&
                         (is_lvalue_reference<_Tp>::value ||
@@ -207,7 +207,7 @@ public:
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
-            : value(_STD::forward<_Tp>(__t))
+            : value(_VSTD::forward<_Tp>(__t))
         {static_assert(!is_lvalue_reference<_Hp>::value ||
                         is_lvalue_reference<_Hp>::value &&
                         (is_lvalue_reference<_Tp>::value ||
@@ -221,7 +221,7 @@ public:
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
-            : value(allocator_arg_t(), __a, _STD::forward<_Tp>(__t))
+            : value(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t))
         {static_assert(!is_lvalue_reference<_Hp>::value ||
                         is_lvalue_reference<_Hp>::value &&
                         (is_lvalue_reference<_Tp>::value ||
@@ -235,7 +235,7 @@ public:
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
-            : value(_STD::forward<_Tp>(__t), __a)
+            : value(_VSTD::forward<_Tp>(__t), __a)
         {static_assert(!is_lvalue_reference<_Hp>::value ||
                         is_lvalue_reference<_Hp>::value &&
                         (is_lvalue_reference<_Tp>::value ||
@@ -260,14 +260,14 @@ public:
         __tuple_leaf&
         operator=(_Tp&& __t)
         {
-            value = _STD::forward<_Tp>(__t);
+            value = _VSTD::forward<_Tp>(__t);
             return *this;
         }
 
     _LIBCPP_INLINE_VISIBILITY
     int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
-        _STD::swap(*this, __t);
+        _VSTD::swap(*this, __t);
         return 0;
     }
 
@@ -302,22 +302,22 @@ public:
               class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(_Tp&& __t)
-            : _Hp(_STD::forward<_Tp>(__t)) {}
+            : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
-            : _Hp(_STD::forward<_Tp>(__t)) {}
+            : _Hp(_VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 1>, const _Alloc& __a, _Tp&& __t)
-            : _Hp(allocator_arg_t(), __a, _STD::forward<_Tp>(__t)) {}
+            : _Hp(allocator_arg_t(), __a, _VSTD::forward<_Tp>(__t)) {}
 
     template <class _Tp, class _Alloc>
         _LIBCPP_INLINE_VISIBILITY
         explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
-            : _Hp(_STD::forward<_Tp>(__t), __a) {}
+            : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
 
     template <class _Tp>
         _LIBCPP_INLINE_VISIBILITY
@@ -329,7 +329,7 @@ public:
         __tuple_leaf&
         operator=(_Tp&& __t)
         {
-            _Hp::operator=(_STD::forward<_Tp>(__t));
+            _Hp::operator=(_VSTD::forward<_Tp>(__t));
             return *this;
         }
 
@@ -337,7 +337,7 @@ public:
     int
     swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
     {
-        _STD::swap(*this, __t);
+        _VSTD::swap(*this, __t);
         return 0;
     }
 
@@ -378,7 +378,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
         __tuple_impl(__tuple_indices<_Uf...>, __tuple_types<_Tf...>,
                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
                      _Up&&... __u) :
-            __tuple_leaf<_Uf, _Tf>(_STD::forward<_Up>(__u))...,
+            __tuple_leaf<_Uf, _Tf>(_VSTD::forward<_Up>(__u))...,
             __tuple_leaf<_Ul, _Tl>()...
             {}
 
@@ -391,7 +391,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
                      __tuple_indices<_Ul...>, __tuple_types<_Tl...>,
                      _Up&&... __u) :
             __tuple_leaf<_Uf, _Tf>(__uses_alloc_ctor<_Tf, _Alloc, _Up>(), __a,
-            _STD::forward<_Up>(__u))...,
+            _VSTD::forward<_Up>(__u))...,
             __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
             {}
 
@@ -403,8 +403,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
              >
         _LIBCPP_INLINE_VISIBILITY
         __tuple_impl(_Tuple&& __t)
-            : __tuple_leaf<_Indx, _Tp>(_STD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
+            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
             {}
 
     template <class _Alloc, class _Tuple,
@@ -417,8 +417,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
         __tuple_impl(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
             : __tuple_leaf<_Indx, _Tp>(__uses_alloc_ctor<_Tp, _Alloc, typename tuple_element<_Indx,
                                        typename __make_tuple_types<_Tuple>::type>::type>(), __a,
-                                       _STD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
+                                       _VSTD::forward<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
             {}
 
     template <class _Tuple>
@@ -430,8 +430,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
         >::type
         operator=(_Tuple&& __t)
         {
-            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_STD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...);
+            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
             return *this;
         }
 
@@ -499,7 +499,7 @@ public:
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    _STD::forward<_Up>(__u)...) {}
+                    _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Alloc, class ..._Up,
               class = typename enable_if
@@ -522,7 +522,7 @@ public:
                     typename __make_tuple_types<tuple, sizeof...(_Up)>::type(),
                     typename __make_tuple_indices<sizeof...(_Tp), sizeof...(_Up)>::type(),
                     typename __make_tuple_types<tuple, sizeof...(_Tp), sizeof...(_Up)>::type(),
-                    _STD::forward<_Up>(__u)...) {}
+                    _VSTD::forward<_Up>(__u)...) {}
 
     template <class _Tuple,
               class = typename enable_if
@@ -532,7 +532,7 @@ public:
              >
         _LIBCPP_INLINE_VISIBILITY
         tuple(_Tuple&& __t)
-            : base_(_STD::forward<_Tuple>(__t)) {}
+            : base_(_VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Alloc, class _Tuple,
               class = typename enable_if
@@ -542,7 +542,7 @@ public:
              >
         _LIBCPP_INLINE_VISIBILITY
         tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
-            : base_(allocator_arg_t(), __a, _STD::forward<_Tuple>(__t)) {}
+            : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
 
     template <class _Tuple,
               class = typename enable_if
@@ -554,7 +554,7 @@ public:
         tuple&
         operator=(_Tuple&& __t)
         {
-            base_.operator=(_STD::forward<_Tuple>(__t));
+            base_.operator=(_VSTD::forward<_Tuple>(__t));
             return *this;
         }
 
@@ -676,7 +676,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 tuple<typename __make_tuple_return<_Tp>::type...>
 make_tuple(_Tp&&... __t)
 {
-    return tuple<typename __make_tuple_return<_Tp>::type...>(_STD::forward<_Tp>(__t)...);
+    return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
 }
 
 template <class... _Tp>
@@ -684,7 +684,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 tuple<_Tp&&...>
 forward_as_tuple(_Tp&&... __t)
 {
-    return tuple<_Tp&&...>(_STD::forward<_Tp>(__t)...);
+    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
 }
 
 template <size_t _I>
@@ -882,8 +882,8 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
     typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
     operator()(tuple<_Types...> __t, _Tuple0&& __t0)
     {
-        return _STD::forward_as_tuple(_STD::forward<_Types>(get<_I0>(__t))...,
-                                      get<_J0>(_STD::forward<_Tuple0>(__t0))...);
+        return _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
+                                      get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
     }
 
     template <class _Tuple0, class _Tuple1, class ..._Tuples>
@@ -897,12 +897,12 @@ struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J
            tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
            typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
            typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
-                           (_STD::forward_as_tuple(
-                              _STD::forward<_Types>(get<_I0>(__t))...,
-                              get<_J0>(_STD::forward<_Tuple0>(__t0))...
+                           (_VSTD::forward_as_tuple(
+                              _VSTD::forward<_Types>(get<_I0>(__t))...,
+                              get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
                             ),
-                            _STD::forward<_Tuple1>(__t1),
-                            _STD::forward<_Tuples>(__tpls)...);
+                            _VSTD::forward<_Tuple1>(__t1),
+                            _VSTD::forward<_Tuples>(__tpls)...);
     }
 };
 
@@ -914,8 +914,8 @@ tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
     typedef typename remove_reference<_Tuple0>::type _T0;
     return __tuple_cat<tuple<>, __tuple_indices<>,
                   typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
-                  (tuple<>(), _STD::forward<_Tuple0>(__t0),
-                                            _STD::forward<_Tuples>(__tpls)...);
+                  (tuple<>(), _VSTD::forward<_Tuple0>(__t0),
+                                            _VSTD::forward<_Tuples>(__tpls)...);
 }
 
 template <class ..._Tp, class _Alloc>
@@ -928,8 +928,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 pair<_T1, _T2>::pair(piecewise_construct_t,
                      tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
                      __tuple_indices<_I1...>, __tuple_indices<_I2...>)
-    :  first(_STD::forward<_Args1>(get<_I1>( __first_args))...),
-      second(_STD::forward<_Args2>(get<_I2>(__second_args))...)
+    :  first(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
+      second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
 {
 }
 

include/type_traits

@@ -818,7 +818,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic
 
 // has_virtual_destructor
 
-#ifdef __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
+#if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
 
 template <class _Tp> struct _LIBCPP_VISIBLE has_virtual_destructor
     : public integral_constant<bool, __has_virtual_destructor(_Tp)> {};
@@ -1208,7 +1208,7 @@ struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...>
 // is_assignable
 
 template <class _Tp, class _Arg>
-decltype((_STD::declval<_Tp>() = _STD::declval<_Arg>(), true_type()))
+decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>(), true_type()))
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __is_assignable_test(_Tp&&, _Arg&&);
 #else
@@ -1265,7 +1265,7 @@ struct __destructible_test
 };
 
 template <class _Tp>
-decltype((_STD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
+decltype((_VSTD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __is_destructible_test(_Tp&&);
 #else
@@ -1428,14 +1428,28 @@ public:
                      >::type type;
 };
 
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename decay<_Tp>::type
 __decay_copy(_Tp&& __t)
 {
-    return _STD::forward<_Tp>(__t);
+    return _VSTD::forward<_Tp>(__t);
 }
 
+#else
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+typename decay<_Tp>::type
+__decay_copy(const _Tp& __t)
+{
+    return _VSTD::forward<_Tp>(__t);
+}
+
+#endif
+
 template <class _MP, bool _IsMemberFuctionPtr, bool _IsMemberObjectPtr>
 struct __member_pointer_traits_imp
 {
@@ -1666,7 +1680,7 @@ struct __member_pointer_traits
 
 // result_of
 
-template <class> class result_of;
+template <class _Callable> class result_of;
 
 template <class _Fn, bool, bool>
 class __result_of
@@ -1701,7 +1715,7 @@ struct __result_of_mdp;
 template <class _R, class _Class, class _Tp>
 struct __result_of_mdp<_R _Class::*, _Tp, false>
 {
-    typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type&& type;
+    typedef typename __apply_cv<decltype(*_VSTD::declval<_Tp>()), _R>::type&& type;
 };
 
 template <class _R, class _Class, class _Tp>
@@ -1786,7 +1800,7 @@ struct __result_of_mdp;
 template <class _R, class _Class, class _Tp>
 struct __result_of_mdp<_R _Class::*, _Tp, false>
 {
-    typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type& type;
+    typedef typename __apply_cv<decltype(*_VSTD::declval<_Tp>()), _R>::type& type;
 };
 
 template <class _R, class _Class, class _Tp>
@@ -1887,7 +1901,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1, _A2)>
 //      main is_constructible test
 
 template <class _Tp, class ..._Args>
-decltype(_STD::move(_Tp(_STD::declval<_Args>()...)), true_type())
+decltype(_VSTD::move(_Tp(_VSTD::declval<_Args>()...)), true_type())
 __is_constructible_test(_Tp&&, _Args&& ...);
 
 template <class ..._Args>
@@ -2014,7 +2028,7 @@ false_type
 __is_constructible0_test(__any);
 
 template <class _Tp, class _A0>
-decltype((_Tp(_STD::declval<_A0>()), true_type()))
+decltype((_Tp(_VSTD::declval<_A0>()), true_type()))
 __is_constructible1_test(_Tp&, _A0&);
 
 template <class _A0>
@@ -2022,7 +2036,7 @@ false_type
 __is_constructible1_test(__any, _A0&);
 
 template <class _Tp, class _A0, class _A1>
-decltype((_Tp(_STD::declval<_A0>(), _STD::declval<_A1>()), true_type()))
+decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>()), true_type()))
 __is_constructible2_test(_Tp&, _A0&, _A1&);
 
 template <class _A0, class _A1>
@@ -2594,7 +2608,7 @@ struct __is_nothrow_assignable<false, _Tp, _Arg>
 
 template <class _Tp, class _Arg>
 struct __is_nothrow_assignable<true, _Tp, _Arg>
-    : public integral_constant<bool, noexcept(_STD::declval<_Tp>() = _STD::declval<_Arg>()) >
+    : public integral_constant<bool, noexcept(_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>()) >
 {
 };
 
@@ -2680,7 +2694,7 @@ struct __is_nothrow_destructible<false, _Tp>
 
 template <class _Tp>
 struct __is_nothrow_destructible<true, _Tp>
-    : public integral_constant<bool, noexcept(_STD::declval<_Tp>().~_Tp()) >
+    : public integral_constant<bool, noexcept(_VSTD::declval<_Tp>().~_Tp()) >
 {
 };
 
@@ -2932,31 +2946,31 @@ __invoke(__any, _Args&& ...__args)
 template <class _F, class _A0, class ..._Args>
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...));
+    -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));
 
 template <class _F, class _A0, class ..._Args>
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...));
+    -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...));
 
 // bullets 3 and 4
 
 template <class _F, class _A0>
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype(_STD::forward<_A0>(__a0).*__f);
+    -> decltype(_VSTD::forward<_A0>(__a0).*__f);
 
 template <class _F, class _A0>
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype((*_STD::forward<_A0>(__a0)).*__f);
+    -> decltype((*_VSTD::forward<_A0>(__a0)).*__f);
 
 // bullet 5
 
 template <class _F, class ..._Args>
 auto
 __invoke(_F&& __f, _Args&& ...__args)
-    -> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...));
+    -> decltype(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...));
 
 // __invokable
 
@@ -2965,7 +2979,7 @@ struct __invokable_imp
     : private __check_complete<_F, _Args...>
 {
     typedef decltype(
-            __invoke(_STD::declval<_F>(), _STD::declval<_Args>()...)
+            __invoke(_VSTD::declval<_F>(), _VSTD::declval<_Args>()...)
                     ) type;
     static const bool value = !is_same<type, __nat>::value;
 };
@@ -3008,9 +3022,9 @@ typename enable_if
 swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
                                     is_nothrow_move_assignable<_Tp>::value)
 {
-    _Tp __t(_STD::move(__x));
-    __x = _STD::move(__y);
-    __y = _STD::move(__t);
+    _Tp __t(_VSTD::move(__x));
+    __x = _VSTD::move(__y);
+    __y = _VSTD::move(__t);
 }
 
 template <class _ForwardIterator1, class _ForwardIterator2>
@@ -3018,8 +3032,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
     //                                  _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
-               _NOEXCEPT_(_NOEXCEPT_(swap(*_STD::declval<_ForwardIterator1>(),
-                                          *_STD::declval<_ForwardIterator2>())))
+               _NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(),
+                                          *_VSTD::declval<_ForwardIterator2>())))
 {
     swap(*__a, *__b);
 }
@@ -3029,13 +3043,13 @@ iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
 namespace __detail
 {
 
-using _STD::swap;
+using _VSTD::swap;
 __nat swap(__any, __any);
 
 template <class _Tp>
 struct __swappable
 {
-    typedef decltype(swap(_STD::declval<_Tp&>(), _STD::declval<_Tp&>())) type;
+    typedef decltype(swap(_VSTD::declval<_Tp&>(), _VSTD::declval<_Tp&>())) type;
     static const bool value = !is_same<type, __nat>::value;
 };
 
@@ -3051,8 +3065,8 @@ struct __is_swappable
 
 template <bool, class _Tp>
 struct __is_nothrow_swappable_imp
-    : public integral_constant<bool, noexcept(swap(_STD::declval<_Tp&>(),
-                                                   _STD::declval<_Tp&>()))>
+    : public integral_constant<bool, noexcept(swap(_VSTD::declval<_Tp&>(),
+                                                   _VSTD::declval<_Tp&>()))>
 {
 };
 

include/unordered_map

@@ -481,9 +481,9 @@ public:
     void operator()(pointer __p) _NOEXCEPT
     {
         if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
         if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
         if (__p)
             __alloc_traits::deallocate(__na_, __p, 1);
     }
@@ -691,7 +691,12 @@ public:
                   const hasher& __hf, const key_equal& __eql,
                   const allocator_type& __a);
     // ~unordered_map() = default;
-    // unordered_map& operator=(const unordered_map& __u) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_map& operator=(const unordered_map& __u)
+    {
+        __table_ = __u.__table_;
+        return *this;
+    }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     unordered_map& operator=(unordered_map&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
@@ -728,15 +733,15 @@ public:
         {return __table_.__emplace_unique();}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_A0&& __a0)
-            {return __table_.__emplace_unique(_STD::forward<_A0>(__a0));}
+            {return __table_.__emplace_unique(_VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class... _Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         pair<iterator, bool> emplace(_A0&& __a0, _Args&&... __args);
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -746,19 +751,19 @@ public:
         {return __table_.__emplace_unique().first;}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator, _A0&& __a0)
-            {return __table_.__emplace_unique(_STD::forward<_A0>(__a0)).first;}
+            {return __table_.__emplace_unique(_VSTD::forward<_A0>(__a0)).first;}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class... _Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator, _A0&& __a0, _Args&&... __args)
-            {return emplace(_STD::forward<_A0>(__a0),
-                            _STD::forward<_Args>(__args)...).first;}
+            {return emplace(_VSTD::forward<_A0>(__a0),
+                            _VSTD::forward<_Args>(__args)...).first;}
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
@@ -766,20 +771,20 @@ public:
         {return __table_.__insert_unique(__x);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> insert(_P&& __x)
-            {return __table_.__insert_unique(_STD::forward<_P>(__x));}
+            {return __table_.__insert_unique(_VSTD::forward<_P>(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, const value_type& __x)
         {return insert(__x).first;}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert(const_iterator, _P&& __x)
-            {return insert(_STD::forward<_P>(__x)).first;}
+            {return insert(_VSTD::forward<_P>(__x)).first;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
@@ -869,11 +874,11 @@ private:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_VARIADICS
     template <class _A0, class... _Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0, _Args&&... __args);
 #endif  // _LIBCPP_HAS_NO_VARIADICS
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0);
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     __node_holder __construct_node(const key_type& __k);
@@ -960,21 +965,21 @@ inline _LIBCPP_INLINE_VISIBILITY
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         unordered_map&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_STD::move(__u.__table_))
+    : __table_(_VSTD::move(__u.__table_))
 {
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_map(
         unordered_map&& __u, const allocator_type& __a)
-    : __table_(_STD::move(__u.__table_), __a)
+    : __table_(_VSTD::move(__u.__table_), __a)
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0)
             __table_.__insert_unique(
-                _STD::move(__u.__table_.remove((__i++).__i_)->__value_)
+                _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_)
                                     );
     }
 }
@@ -1016,7 +1021,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_map&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
-    __table_ = _STD::move(__u.__table_);
+    __table_ = _VSTD::move(__u.__table_);
     return *this;
 }
 
@@ -1037,7 +1042,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0, class... _Args,
-          class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
+          class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
          >
 typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
@@ -1045,11 +1050,11 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first),
-                             _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first),
+                             _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second),
-                             _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second),
+                             _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
@@ -1058,15 +1063,15 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0,
-          class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
+          class // = typename enable_if<is_constructible<value_type, _A0>::value>::type
          >
 typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_),
-                             _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
+                             _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
     __h.get_deleter().__second_constructed = true;
     return __h;
@@ -1076,13 +1081,13 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0, class... _Args,
-          class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
+          class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
          >
 pair<typename unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator, bool>
 unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
     if (__r.second)
         __h.release();
@@ -1098,11 +1103,11 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type&
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first), __k);
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
     __h.get_deleter().__second_constructed = true;
-    return _STD::move(__h);
+    return _VSTD::move(__h);
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1140,7 +1145,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::operator[](key_type&& __k)
     iterator __i = find(__k);
     if (__i != end())
         return __i->second;
-    __node_holder __h = __construct_node(_STD::move(__k));
+    __node_holder __h = __construct_node(_VSTD::move(__k));
     pair<iterator, bool> __r = __table_.__node_insert_unique(__h.get());
     __h.release();
     return __r.first->second;
@@ -1295,7 +1300,12 @@ public:
                        const hasher& __hf, const key_equal& __eql,
                        const allocator_type& __a);
     // ~unordered_multimap() = default;
-    // unordered_multimap& operator=(const unordered_multimap& __u) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multimap& operator=(const unordered_multimap& __u)
+    {
+        __table_ = __u.__table_;
+        return *this;
+    }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     unordered_multimap& operator=(unordered_multimap&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
@@ -1332,15 +1342,15 @@ public:
         {return __table_.__emplace_multi();}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_A0&& __a0)
-            {return __table_.__emplace_multi(_STD::forward<_A0>(__a0));}
+            {return __table_.__emplace_multi(_VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class... _Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         iterator emplace(_A0&& __a0, _Args&&... __args);
 
 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -1350,15 +1360,15 @@ public:
         {return __table_.__emplace_hint_multi(__p.__i_);}
 
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _A0&& __a0)
-            {return __table_.__emplace_hint_multi(__p.__i_, _STD::forward<_A0>(__a0));}
+            {return __table_.__emplace_hint_multi(__p.__i_, _VSTD::forward<_A0>(__a0));}
 
 #ifndef _LIBCPP_HAS_NO_VARIADICS
 
     template <class _A0, class... _Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         iterator emplace_hint(const_iterator __p, _A0&& __a0, _Args&&... __args);
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1366,20 +1376,20 @@ public:
     iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert(_P&& __x)
-            {return __table_.__insert_multi(_STD::forward<_P>(__x));}
+            {return __table_.__insert_multi(_VSTD::forward<_P>(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __x)
         {return __table_.__insert_multi(__p.__i_, __x);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _P,
-              class = typename enable_if<is_convertible<_P, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _P>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         iterator insert(const_iterator __p, _P&& __x)
-            {return __table_.__insert_multi(__p.__i_, _STD::forward<_P>(__x));}
+            {return __table_.__insert_multi(__p.__i_, _VSTD::forward<_P>(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
@@ -1461,10 +1471,10 @@ public:
 private:
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     template <class _A0, class... _Args,
-              class = typename enable_if<is_convertible<_A0, key_type>::value>::type>
+              class = typename enable_if<is_constructible<key_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0, _Args&&... __args);
     template <class _A0,
-              class = typename enable_if<is_convertible<_A0, value_type>::value>::type>
+              class = typename enable_if<is_constructible<value_type, _A0>::value>::type>
         __node_holder __construct_node(_A0&& __a0);
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
 };
@@ -1549,14 +1559,14 @@ inline _LIBCPP_INLINE_VISIBILITY
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         unordered_multimap&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_STD::move(__u.__table_))
+    : __table_(_VSTD::move(__u.__table_))
 {
 }
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         unordered_multimap&& __u, const allocator_type& __a)
-    : __table_(_STD::move(__u.__table_), __a)
+    : __table_(_VSTD::move(__u.__table_), __a)
 {
     if (__a != __u.get_allocator())
     {
@@ -1564,7 +1574,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::unordered_multimap(
         while (__u.size() != 0)
 {
             __table_.__insert_multi(
-                _STD::move(__u.__table_.remove((__i++).__i_)->__value_)
+                _VSTD::move(__u.__table_.remove((__i++).__i_)->__value_)
                                    );
 }
     }
@@ -1607,7 +1617,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>&
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(unordered_multimap&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
-    __table_ = _STD::move(__u.__table_);
+    __table_ = _VSTD::move(__u.__table_);
     return *this;
 }
 
@@ -1628,7 +1638,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::operator=(
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0, class... _Args,
-          class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
+          class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
          >
 typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
@@ -1636,11 +1646,11 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first),
-                             _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.first),
+                             _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second),
-                             _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second),
+                             _VSTD::forward<_Args>(__args)...);
     __h.get_deleter().__second_constructed = true;
     return __h;
 }
@@ -1649,15 +1659,15 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0,
-          class // = typename enable_if<is_convertible<_A0, value_type>::value>::type
+          class // = typename enable_if<is_constructible<value_type, _A0>::value>::type
          >
 typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__node_holder
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
 {
     __node_allocator& __na = __table_.__node_alloc();
     __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_),
-                             _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, _VSTD::addressof(__h->__value_),
+                             _VSTD::forward<_A0>(__a0));
     __h.get_deleter().__first_constructed = true;
     __h.get_deleter().__second_constructed = true;
     return __h;
@@ -1667,13 +1677,13 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0, class... _Args,
-          class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
+          class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
          >
 typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     iterator __r = __table_.__node_insert_multi(__h.get());
     __h.release();
     return __r;
@@ -1681,14 +1691,14 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace(_A0&& __a0, _Args&&
 
 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
 template <class _A0, class... _Args,
-          class // = typename enable_if<is_convertible<_A0, key_type>::value>::type
+          class // = typename enable_if<is_constructible<key_type, _A0>::value>::type
          >
 typename unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::iterator
 unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::emplace_hint(
         const_iterator __p, _A0&& __a0, _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_STD::forward<_A0>(__a0),
-                                         _STD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_VSTD::forward<_A0>(__a0),
+                                         _VSTD::forward<_Args>(__args)...);
     iterator __r = __table_.__node_insert_multi(__p.__i_, __h.get());
     __h.release();
     return __r;
@@ -1732,9 +1742,9 @@ operator==(const unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>& __x,
     {
         _EqRng __xeq = __x.equal_range(__i->first);
         _EqRng __yeq = __y.equal_range(__i->first);
-        if (_STD::distance(__xeq.first, __xeq.second) !=
-            _STD::distance(__yeq.first, __yeq.second) ||
-                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_VSTD::distance(__xeq.first, __xeq.second) !=
+            _VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
             return false;
         __i = __xeq.second;
     }

include/unordered_set

@@ -373,7 +373,12 @@ public:
                   const hasher& __hf, const key_equal& __eql,
                   const allocator_type& __a);
     // ~unordered_set() = default;
-    // unordered_set& operator=(const unordered_set& __u) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_set& operator=(const unordered_set& __u)
+    {
+        __table_ = __u.__table_;
+        return *this;
+    }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     unordered_set& operator=(unordered_set&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
@@ -408,11 +413,11 @@ public:
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         pair<iterator, bool> emplace(_Args&&... __args)
-            {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...);}
+            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator, _Args&&... __args)
-            {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...).first;}
+            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;}
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator, bool> insert(const value_type& __x)
@@ -420,7 +425,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     pair<iterator, bool> insert(value_type&& __x)
-        {return __table_.__insert_unique(_STD::move(__x));}
+        {return __table_.__insert_unique(_VSTD::move(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, const value_type& __x)
@@ -428,7 +433,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator, value_type&& __x)
-        {return insert(_STD::move(__x)).first;}
+        {return insert(_VSTD::move(__x)).first;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
@@ -583,20 +588,20 @@ inline _LIBCPP_INLINE_VISIBILITY
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         unordered_set&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_STD::move(__u.__table_))
+    : __table_(_VSTD::move(__u.__table_))
 {
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
         unordered_set&& __u, const allocator_type& __a)
-    : __table_(_STD::move(__u.__table_), __a)
+    : __table_(_VSTD::move(__u.__table_), __a)
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0)
-            __table_.__insert_unique(_STD::move(__u.__table_.remove(__i++)->__value_));
+            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_));
     }
 }
 
@@ -637,7 +642,7 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
-    __table_ = _STD::move(__u.__table_);
+    __table_ = _VSTD::move(__u.__table_);
     return *this;
 }
 
@@ -766,7 +771,12 @@ public:
                        const hasher& __hf, const key_equal& __eql,
                        const allocator_type& __a);
     // ~unordered_multiset() = default;
-    // unordered_multiset& operator=(const unordered_multiset& __u) = default;
+    _LIBCPP_INLINE_VISIBILITY
+    unordered_multiset& operator=(const unordered_multiset& __u)
+    {
+        __table_ = __u.__table_;
+        return *this;
+    }
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     unordered_multiset& operator=(unordered_multiset&& __u)
         _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
@@ -801,17 +811,17 @@ public:
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace(_Args&&... __args)
-            {return __table_.__emplace_multi(_STD::forward<_Args>(__args)...);}
+            {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
     template <class... _Args>
         _LIBCPP_INLINE_VISIBILITY
         iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __table_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
+            {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
-    iterator insert(value_type&& __x) {return __table_.__insert_multi(_STD::move(__x));}
+    iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));}
 #endif
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, const value_type& __x)
@@ -819,7 +829,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
     _LIBCPP_INLINE_VISIBILITY
     iterator insert(const_iterator __p, value_type&& __x)
-        {return __table_.__insert_multi(__p, _STD::move(__x));}
+        {return __table_.__insert_multi(__p, _VSTD::move(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
     template <class _InputIterator>
         void insert(_InputIterator __first, _InputIterator __last);
@@ -975,20 +985,20 @@ inline _LIBCPP_INLINE_VISIBILITY
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         unordered_multiset&& __u)
     _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_STD::move(__u.__table_))
+    : __table_(_VSTD::move(__u.__table_))
 {
 }
 
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
         unordered_multiset&& __u, const allocator_type& __a)
-    : __table_(_STD::move(__u.__table_), __a)
+    : __table_(_VSTD::move(__u.__table_), __a)
 {
     if (__a != __u.get_allocator())
     {
         iterator __i = __u.begin();
         while (__u.size() != 0)
-            __table_.__insert_multi(_STD::move(__u.__table_.remove(__i++)->__value_));
+            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_));
     }
 }
 
@@ -1030,7 +1040,7 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
         unordered_multiset&& __u)
     _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
-    __table_ = _STD::move(__u.__table_);
+    __table_ = _VSTD::move(__u.__table_);
     return *this;
 }
 
@@ -1081,9 +1091,9 @@ operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
     {
         _EqRng __xeq = __x.equal_range(*__i);
         _EqRng __yeq = __y.equal_range(*__i);
-        if (_STD::distance(__xeq.first, __xeq.second) !=
-            _STD::distance(__yeq.first, __yeq.second) ||
-                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_VSTD::distance(__xeq.first, __xeq.second) !=
+            _VSTD::distance(__yeq.first, __yeq.second) ||
+                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
             return false;
         __i = __xeq.second;
     }

include/utility

@@ -183,7 +183,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(_Tp (&__a)[_N], _Tp (&__b)[_N]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
 {
-    _STD::swap_ranges(__a, __a + _N, __b);
+    _VSTD::swap_ranges(__a, __a + _N, __b);
 }
 
 template <class _Tp>
@@ -200,7 +200,7 @@ const _Tp&
 #endif
 move_if_noexcept(_Tp& __x) _NOEXCEPT
 {
-    return _STD::move(__x);
+    return _VSTD::move(__x);
 }
 
 struct _LIBCPP_VISIBLE piecewise_construct_t { };
@@ -227,12 +227,23 @@ struct _LIBCPP_VISIBLE pair
     template<class _U1, class _U2>
         _LIBCPP_INLINE_VISIBILITY
         pair(const pair<_U1, _U2>& __p,
-                 typename enable_if<is_convertible<_U1, _T1>::value &&
-                                    is_convertible<_U2, _T2>::value>::type* = 0)
+                 typename enable_if<is_constructible<_T1, _U1>::value &&
+                                    is_constructible<_T2, _U2>::value>::type* = 0)
             : first(__p.first), second(__p.second) {}
 
+    _LIBCPP_INLINE_VISIBILITY
+    pair(const pair& __p)
+        _NOEXCEPT_(is_nothrow_copy_constructible<first_type>::value &&
+                   is_nothrow_copy_constructible<second_type>::value)
+        : first(__p.first),
+          second(__p.second)
+    {
+    }
+
     _LIBCPP_INLINE_VISIBILITY
     pair& operator=(const pair& __p)
+        _NOEXCEPT_(is_nothrow_copy_assignable<first_type>::value &&
+                   is_nothrow_copy_assignable<second_type>::value)
     {
         first = __p.first;
         second = __p.second;
@@ -242,29 +253,37 @@ struct _LIBCPP_VISIBLE pair
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 
     template <class _U1, class _U2,
-              class = typename enable_if<is_convertible<_U1, first_type >::value &&
-                                         is_convertible<_U2, second_type>::value>::type>
+              class = typename enable_if<is_constructible<first_type, _U1 >::value &&
+                                         is_constructible<second_type, _U2>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair(_U1&& __u1, _U2&& __u2)
-            : first(_STD::forward<_U1>(__u1)),
-              second(_STD::forward<_U2>(__u2))
+            : first(_VSTD::forward<_U1>(__u1)),
+              second(_VSTD::forward<_U2>(__u2))
             {}
 
     template<class _U1, class _U2>
         _LIBCPP_INLINE_VISIBILITY
         pair(pair<_U1, _U2>&& __p,
-                 typename enable_if<is_convertible<_U1, _T1>::value &&
-                                    is_convertible<_U2, _T2>::value>::type* = 0)
-            : first(_STD::forward<_U1>(__p.first)),
-              second(_STD::forward<_U2>(__p.second)) {}
+                 typename enable_if<is_constructible<_T1, _U1>::value &&
+                                    is_constructible<_T2, _U2>::value>::type* = 0)
+            : first(_VSTD::forward<_U1>(__p.first)),
+              second(_VSTD::forward<_U2>(__p.second)) {}
+
+    _LIBCPP_INLINE_VISIBILITY
+    pair(pair&& __p) _NOEXCEPT_(is_nothrow_move_constructible<first_type>::value &&
+                                is_nothrow_move_constructible<second_type>::value)
+        : first(_VSTD::forward<first_type>(__p.first)),
+          second(_VSTD::forward<second_type>(__p.second))
+    {
+    }
 
     _LIBCPP_INLINE_VISIBILITY
     pair&
     operator=(pair&& __p) _NOEXCEPT_(is_nothrow_move_assignable<first_type>::value &&
                                      is_nothrow_move_assignable<second_type>::value)
     {
-        first = _STD::forward<first_type>(__p.first);
-        second = _STD::forward<second_type>(__p.second);
+        first = _VSTD::forward<first_type>(__p.first);
+        second = _VSTD::forward<second_type>(__p.second);
         return *this;
     }
 
@@ -274,9 +293,9 @@ struct _LIBCPP_VISIBLE pair
              class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
         _LIBCPP_INLINE_VISIBILITY
         pair(_Tuple&& __p)
-            : first(_STD::forward<typename tuple_element<0,
+            : first(_VSTD::forward<typename tuple_element<0,
                                   typename __make_tuple_types<_Tuple>::type>::type>(get<0>(__p))),
-              second(_STD::forward<typename tuple_element<1,
+              second(_VSTD::forward<typename tuple_element<1,
                                    typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
             {}
 
@@ -300,8 +319,8 @@ struct _LIBCPP_VISIBLE pair
             typedef typename __make_tuple_types<_Tuple>::type _TupleRef;
             typedef typename tuple_element<0, _TupleRef>::type _U0;
             typedef typename tuple_element<1, _TupleRef>::type _U1;
-            first  = _STD::forward<_U0>(_STD::get<0>(__p));
-            second = _STD::forward<_U1>(_STD::get<1>(__p));
+            first  = _VSTD::forward<_U0>(_VSTD::get<0>(__p));
+            second = _VSTD::forward<_U1>(_VSTD::get<1>(__p));
             return *this;
         }
 
@@ -313,8 +332,8 @@ struct _LIBCPP_VISIBLE pair
     swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
                                __is_nothrow_swappable<second_type>::value)
     {
-        _STD::iter_swap(&first, &__p.first);
-        _STD::iter_swap(&second, &__p.second);
+        _VSTD::iter_swap(&first, &__p.first);
+        _VSTD::iter_swap(&second, &__p.second);
     }
 private:
 
@@ -418,7 +437,7 @@ pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::t
 make_pair(_T1&& __t1, _T2&& __t2)
 {
     return pair<typename __make_pair_return<_T1>::type, typename __make_pair_return<_T2>::type>
-               (_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
+               (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
 }
 
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -494,7 +513,7 @@ struct __get_pair<0>
     static
     _LIBCPP_INLINE_VISIBILITY
     _T1&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _STD::forward<_T1>(__p.first);}
+    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
@@ -520,7 +539,7 @@ struct __get_pair<1>
     static
     _LIBCPP_INLINE_VISIBILITY
     _T2&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _STD::forward<_T2>(__p.second);}
+    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
@@ -548,7 +567,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
 get(pair<_T1, _T2>&& __p) _NOEXCEPT
 {
-    return __get_pair<_Ip>::get(_STD::move(__p));
+    return __get_pair<_Ip>::get(_VSTD::move(__p));
 }
 
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

include/valarray

@@ -2862,7 +2862,7 @@ valarray<_Tp>::operator=(const valarray& __v)
     {
         if (size() != __v.size())
             resize(__v.size());
-        _STD::copy(__v.__begin_, __v.__end_, __begin_);
+        _VSTD::copy(__v.__begin_, __v.__end_, __begin_);
     }
     return *this;
 }
@@ -2889,7 +2889,7 @@ valarray<_Tp>::operator=(initializer_list<value_type> __il)
 {
     if (size() != __il.size())
         resize(__il.size());
-    _STD::copy(__il.begin(), __il.end(), __begin_);
+    _VSTD::copy(__il.begin(), __il.end(), __begin_);
     return *this;
 }
 
@@ -2900,7 +2900,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 valarray<_Tp>&
 valarray<_Tp>::operator=(const value_type& __x)
 {
-    _STD::fill(__begin_, __end_, __x);
+    _VSTD::fill(__begin_, __end_, __x);
     return *this;
 }
 
@@ -3415,8 +3415,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 valarray<_Tp>::swap(valarray& __v)
 {
-    _STD::swap(__begin_, __v.__begin_);
-    _STD::swap(__end_, __v.__end_);
+    _VSTD::swap(__begin_, __v.__begin_);
+    _VSTD::swap(__end_, __v.__end_);
 }
 
 template <class _Tp>
@@ -3440,7 +3440,7 @@ valarray<_Tp>::min() const
 {
     if (__begin_ == __end_)
         return value_type();
-    return *_STD::min_element(__begin_, __end_);
+    return *_VSTD::min_element(__begin_, __end_);
 }
 
 template <class _Tp>
@@ -3450,7 +3450,7 @@ valarray<_Tp>::max() const
 {
     if (__begin_ == __end_)
         return value_type();
-    return *_STD::max_element(__begin_, __end_);
+    return *_VSTD::max_element(__begin_, __end_);
 }
 
 template <class _Tp>
@@ -3469,14 +3469,14 @@ valarray<_Tp>::shift(int __i) const
         value_type* __te;
         if (__i >= 0)
         {
-            __i = _STD::min(__i, static_cast<int>(__n));
+            __i = _VSTD::min(__i, static_cast<int>(__n));
             __sb = __begin_ + __i;
             __tb = __r.__begin_;
             __te = __r.__begin_ + (__n - __i);
         }
         else
         {
-            __i = _STD::min(-__i, static_cast<int>(__n));
+            __i = _VSTD::min(-__i, static_cast<int>(__n));
             __sb = __begin_;
             __tb = __r.__begin_ + __i;
             __te = __r.__begin_ + __n;

include/vector

@@ -405,7 +405,7 @@ private:
     void __move_assign_alloc(const __vector_base& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
-            __alloc() = _STD::move(__c.__alloc());
+            __alloc() = _VSTD::move(__c.__alloc());
         }
 
     _LIBCPP_INLINE_VISIBILITY
@@ -417,7 +417,7 @@ private:
     static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
     _LIBCPP_INLINE_VISIBILITY
@@ -507,8 +507,8 @@ public:
     typedef __wrap_iter<pointer>                     iterator;
     typedef __wrap_iter<const_pointer>               const_iterator;
 #endif  // defined(_LIBCPP_RAW_ITERATORS)
-    typedef _STD::reverse_iterator<iterator>         reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator>   const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
 
     _LIBCPP_INLINE_VISIBILITY
     vector()
@@ -642,10 +642,10 @@ public:
 
     _LIBCPP_INLINE_VISIBILITY
     value_type*       data() _NOEXCEPT
-        {return _STD::__to_raw_pointer(this->__begin_);}
+        {return _VSTD::__to_raw_pointer(this->__begin_);}
     _LIBCPP_INLINE_VISIBILITY
     const value_type* data() const _NOEXCEPT
-        {return _STD::__to_raw_pointer(this->__begin_);}
+        {return _VSTD::__to_raw_pointer(this->__begin_);}
 
     _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -735,10 +735,10 @@ void
 vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v)
 {
     for (pointer __p = this->__end_; this->__begin_ < __p;)
-        __v.push_front(_STD::move_if_noexcept(*--__p));
-    _STD::swap(this->__begin_, __v.__begin_);
-    _STD::swap(this->__end_, __v.__end_);
-    _STD::swap(this->__end_cap(), __v.__end_cap());
+        __v.push_front(_VSTD::move_if_noexcept(*--__p));
+    _VSTD::swap(this->__begin_, __v.__begin_);
+    _VSTD::swap(this->__end_, __v.__end_);
+    _VSTD::swap(this->__end_cap(), __v.__end_cap());
     __v.__first_ = __v.__begin_;
     __invalidate_all_iterators();
 }
@@ -749,12 +749,12 @@ vector<_Tp, _Allocator>::__swap_out_circular_buffer(__split_buffer<value_type, a
 {
     pointer __r = __v.__begin_;
     for (pointer __i = __p; this->__begin_ < __i;)
-        __v.push_front(_STD::move_if_noexcept(*--__i));
+        __v.push_front(_VSTD::move_if_noexcept(*--__i));
     for (pointer __i = __p; __i < this->__end_; ++__i)
-        __v.push_back(_STD::move_if_noexcept(*__i));
-    _STD::swap(this->__begin_, __v.__begin_);
-    _STD::swap(this->__end_, __v.__end_);
-    _STD::swap(this->__end_cap(), __v.__end_cap());
+        __v.push_back(_VSTD::move_if_noexcept(*__i));
+    _VSTD::swap(this->__begin_, __v.__begin_);
+    _VSTD::swap(this->__end_, __v.__end_);
+    _VSTD::swap(this->__end_cap(), __v.__end_cap());
     __v.__first_ = __v.__begin_;
     __invalidate_all_iterators();
     return __r;
@@ -794,7 +794,7 @@ template <class _Tp, class _Allocator>
 typename vector<_Tp, _Allocator>::size_type
 vector<_Tp, _Allocator>::max_size() const _NOEXCEPT
 {
-    return _STD::min(__alloc_traits::max_size(this->__alloc()), numeric_limits<size_type>::max() / 2);  // end() >= begin(), always
+    return _VSTD::min(__alloc_traits::max_size(this->__alloc()), numeric_limits<size_type>::max() / 2);  // end() >= begin(), always
 }
 
 //  Precondition:  __new_size > capacity()
@@ -809,7 +809,7 @@ vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
     const size_type __cap = capacity();
     if (__cap >= __ms / 2)
         return __ms;
-    return _STD::max(2*__cap, __new_size);
+    return _VSTD::max(2*__cap, __new_size);
 }
 
 //  Default constructs __n objects starting at __end_
@@ -824,7 +824,7 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
     allocator_type& __a = this->__alloc();
     do
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_));
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
         ++this->__end_;
         --__n;
     } while (__n > 0);
@@ -844,7 +844,7 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
     allocator_type& __a = this->__alloc();
     do
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), __x);
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
         ++this->__end_;
         --__n;
     } while (__n > 0);
@@ -862,7 +862,7 @@ vector<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIt
     allocator_type& __a = this->__alloc();
     for (; __first != __last; ++__first)
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
         ++this->__end_;
     }
 }
@@ -874,8 +874,8 @@ vector<_Tp, _Allocator>::__move_construct_at_end(pointer __first, pointer __last
     allocator_type& __a = this->__alloc();
     for (; __first != __last; ++__first)
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_),
-                                  _STD::move(*__first));
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
+                                  _VSTD::move(*__first));
         ++this->__end_;
     }
 }
@@ -975,7 +975,7 @@ template <class _ForwardIterator>
 vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __last,
                                 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
 {
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         allocate(__n);
@@ -989,7 +989,7 @@ vector<_Tp, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __las
                                 typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type*)
     : __base(__a)
 {
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         allocate(__n);
@@ -1027,7 +1027,7 @@ template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 vector<_Tp, _Allocator>::vector(vector&& __x)
         _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-    : __base(_STD::move(__x.__alloc()))
+    : __base(_VSTD::move(__x.__alloc()))
 {
     this->__begin_ = __x.__begin_;
     this->__end_ = __x.__end_;
@@ -1157,7 +1157,7 @@ typename enable_if
 >::type
 vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
-    typename iterator_traits<_ForwardIterator>::difference_type __new_size = _STD::distance(__first, __last);
+    typename iterator_traits<_ForwardIterator>::difference_type __new_size = _VSTD::distance(__first, __last);
     if (static_cast<size_type>(__new_size) <= capacity())
     {
         _ForwardIterator __mid = __last;
@@ -1166,9 +1166,9 @@ vector<_Tp, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __las
         {
             __growing = true;
             __mid =  __first;
-            _STD::advance(__mid, size());
+            _VSTD::advance(__mid, size());
         }
-        pointer __m = _STD::copy(__first, __mid, this->__begin_);
+        pointer __m = _VSTD::copy(__first, __mid, this->__begin_);
         if (__growing)
             __construct_at_end(__mid, __last);
         else
@@ -1189,7 +1189,7 @@ vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
     if (__n <= capacity())
     {
         size_type __s = size();
-        _STD::fill_n(this->__begin_, _STD::min(__n, __s), __u);
+        _VSTD::fill_n(this->__begin_, _VSTD::min(__n, __s), __u);
         if (__n > __s)
             __construct_at_end(__n - __s, __u);
         else
@@ -1340,7 +1340,7 @@ vector<_Tp, _Allocator>::push_back(const_reference __x)
     if (this->__end_ < this->__end_cap())
     {
         __alloc_traits::construct(this->__alloc(),
-                                  _STD::__to_raw_pointer(this->__end_), __x);
+                                  _VSTD::__to_raw_pointer(this->__end_), __x);
         ++this->__end_;
     }
     else
@@ -1361,15 +1361,15 @@ vector<_Tp, _Allocator>::push_back(value_type&& __x)
     if (this->__end_ < this->__end_cap())
     {
         __alloc_traits::construct(this->__alloc(),
-                                  _STD::__to_raw_pointer(this->__end_),
-                                  _STD::move(__x));
+                                  _VSTD::__to_raw_pointer(this->__end_),
+                                  _VSTD::move(__x));
         ++this->__end_;
     }
     else
     {
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
-        __v.push_back(_STD::move(__x));
+        __v.push_back(_VSTD::move(__x));
         __swap_out_circular_buffer(__v);
     }
 }
@@ -1384,15 +1384,15 @@ vector<_Tp, _Allocator>::emplace_back(_Args&&... __args)
     if (this->__end_ < this->__end_cap())
     {
         __alloc_traits::construct(this->__alloc(),
-                                  _STD::__to_raw_pointer(this->__end_),
-                                  _STD::forward<_Args>(__args)...);
+                                  _VSTD::__to_raw_pointer(this->__end_),
+                                  _VSTD::forward<_Args>(__args)...);
         ++this->__end_;
     }
     else
     {
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), size(), __a);
-        __v.emplace_back(_STD::forward<_Args>(__args)...);
+        __v.emplace_back(_VSTD::forward<_Args>(__args)...);
         __swap_out_circular_buffer(__v);
     }
 }
@@ -1415,7 +1415,7 @@ vector<_Tp, _Allocator>::erase(const_iterator __position)
 {
     pointer __p = const_cast<pointer>(&*__position);
     iterator __r = __make_iter(__p);
-    this->__destruct_at_end(_STD::move(__p + 1, this->__end_, __p));
+    this->__destruct_at_end(_VSTD::move(__p + 1, this->__end_, __p));
     return __r;
 }
 
@@ -1425,7 +1425,7 @@ vector<_Tp, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
     pointer __p = this->__begin_ + (__first - begin());
     iterator __r = __make_iter(__p);
-    this->__destruct_at_end(_STD::move(__p + (__last - __first), this->__end_, __p));
+    this->__destruct_at_end(_VSTD::move(__p + (__last - __first), this->__end_, __p));
     return __r;
 }
 
@@ -1437,9 +1437,9 @@ vector<_Tp, _Allocator>::__move_range(pointer __from_s, pointer __from_e, pointe
     difference_type __n = __old_last - __to;
     for (pointer __i = __from_s + __n; __i < __from_e; ++__i, ++this->__end_)
         __alloc_traits::construct(this->__alloc(),
-                                  _STD::__to_raw_pointer(this->__end_),
-                                  _STD::move(*__i));
-    _STD::move_backward(__from_s, __from_s + __n, __old_last);
+                                  _VSTD::__to_raw_pointer(this->__end_),
+                                  _VSTD::move(*__i));
+    _VSTD::move_backward(__from_s, __from_s + __n, __old_last);
 }
 
 template <class _Tp, class _Allocator>
@@ -1452,7 +1452,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, const_reference __x)
         if (__p == this->__end_)
         {
             __alloc_traits::construct(this->__alloc(),
-                                      _STD::__to_raw_pointer(this->__end_), __x);
+                                      _VSTD::__to_raw_pointer(this->__end_), __x);
             ++this->__end_;
         }
         else
@@ -1486,21 +1486,21 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, value_type&& __x)
         if (__p == this->__end_)
         {
             __alloc_traits::construct(this->__alloc(),
-                                      _STD::__to_raw_pointer(this->__end_),
-                                      _STD::move(__x));
+                                      _VSTD::__to_raw_pointer(this->__end_),
+                                      _VSTD::move(__x));
             ++this->__end_;
         }
         else
         {
             __move_range(__p, this->__end_, __p + 1);
-            *__p = _STD::move(__x);
+            *__p = _VSTD::move(__x);
         }
     }
     else
     {
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
-        __v.push_back(_STD::move(__x));
+        __v.push_back(_VSTD::move(__x));
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
@@ -1519,21 +1519,21 @@ vector<_Tp, _Allocator>::emplace(const_iterator __position, _Args&&... __args)
         if (__p == this->__end_)
         {
             __alloc_traits::construct(this->__alloc(),
-                                      _STD::__to_raw_pointer(this->__end_),
-                                      _STD::forward<_Args>(__args)...);
+                                      _VSTD::__to_raw_pointer(this->__end_),
+                                      _VSTD::forward<_Args>(__args)...);
             ++this->__end_;
         }
         else
         {
             __move_range(__p, this->__end_, __p + 1);
-            *__p = value_type(_STD::forward<_Args>(__args)...);
+            *__p = value_type(_VSTD::forward<_Args>(__args)...);
         }
     }
     else
     {
         allocator_type& __a = this->__alloc();
         __split_buffer<value_type, allocator_type&> __v(__recommend(size() + 1), __p - this->__begin_, __a);
-        __v.emplace_back(_STD::forward<_Args>(__args)...);
+        __v.emplace_back(_VSTD::forward<_Args>(__args)...);
         __p = __swap_out_circular_buffer(__v, __p);
     }
     return __make_iter(__p);
@@ -1565,7 +1565,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, size_type __n, const_
                 const_pointer __xr = pointer_traits<const_pointer>::pointer_to(__x);
                 if (__p <= __xr && __xr < this->__end_)
                     __xr += __old_n;
-                _STD::fill_n(__p, __n, *__xr);
+                _VSTD::fill_n(__p, __n, *__xr);
             }
         }
         else
@@ -1595,7 +1595,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __firs
     pointer __old_last = this->__end_;
     for (; this->__end_ != this->__end_cap() && __first != __last; ++__first)
     {
-        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_),
+        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_),
                                   *__first);
         ++this->__end_;
     }
@@ -1621,7 +1621,7 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _InputIterator __firs
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
-    __p = _STD::rotate(__p, __old_last, this->__end_);
+    __p = _VSTD::rotate(__p, __old_last, this->__end_);
     insert(__make_iter(__p), move_iterator<iterator>(__v.begin()),
                                     move_iterator<iterator>(__v.end()));
     return begin() + __off;
@@ -1637,7 +1637,7 @@ typename enable_if
 vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
     pointer __p = this->__begin_ + (__position - begin());
-    difference_type __n = _STD::distance(__first, __last);
+    difference_type __n = _VSTD::distance(__first, __last);
     if (__n > 0)
     {
         if (__n <= this->__end_cap() - this->__end_)
@@ -1649,14 +1649,14 @@ vector<_Tp, _Allocator>::insert(const_iterator __position, _ForwardIterator __fi
             if (__n > __dx)
             {
                 __m = __first;
-                _STD::advance(__m, this->__end_ - __p);
+                _VSTD::advance(__m, this->__end_ - __p);
                 __construct_at_end(__m, __last);
                 __n = __dx;
             }
             if (__n > 0)
             {
                 __move_range(__p, __old_last, __p + __old_n);
-                _STD::copy(__first, __m, __p);
+                _VSTD::copy(__first, __m, __p);
             }
         }
         else
@@ -1698,9 +1698,9 @@ vector<_Tp, _Allocator>::swap(vector& __x)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<allocator_type>::value)
 {
-    _STD::swap(this->__begin_, __x.__begin_);
-    _STD::swap(this->__end_, __x.__end_);
-    _STD::swap(this->__end_cap(), __x.__end_cap());
+    _VSTD::swap(this->__begin_, __x.__begin_);
+    _VSTD::swap(this->__end_, __x.__end_);
+    _VSTD::swap(this->__end_cap(), __x.__end_cap());
     __base::__swap_alloc(this->__alloc(), __x.__alloc());
 #ifdef _LIBCPP_DEBUG
     iterator::swap(this, &__x);
@@ -1748,6 +1748,12 @@ template <class _Allocator> class vector<bool, _Allocator>;
 
 template <class _Allocator> struct hash<vector<bool, _Allocator> >;
 
+template <class _Allocator>
+struct __has_storage_type<vector<bool, _Allocator> >
+{
+    static const bool value = true;
+};
+
 template <class _Allocator>
 class _LIBCPP_VISIBLE vector<bool, _Allocator>
     : private __vector_base_common<true>
@@ -1757,8 +1763,6 @@ public:
     typedef bool                                     value_type;
     typedef _Allocator                               allocator_type;
     typedef allocator_traits<allocator_type>         __alloc_traits;
-    typedef __bit_reference<vector>                  reference;
-    typedef __bit_const_reference<vector>            const_reference;
     typedef typename __alloc_traits::size_type       size_type;
     typedef typename __alloc_traits::difference_type difference_type;
     typedef __bit_iterator<vector, false>            pointer;
@@ -1778,8 +1782,8 @@ public:
     typedef pointer                                  iterator;
     typedef const_pointer                            const_iterator;
 #endif  // _LIBCPP_DEBUG
-    typedef _STD::reverse_iterator<iterator>         reverse_iterator;
-    typedef _STD::reverse_iterator<const_iterator>   const_reverse_iterator;
+    typedef _VSTD::reverse_iterator<iterator>         reverse_iterator;
+    typedef _VSTD::reverse_iterator<const_iterator>   const_reverse_iterator;
 
 private:
     typedef size_type __storage_type;
@@ -1797,7 +1801,10 @@ private:
     __storage_pointer                                      __begin_;
     size_type                                              __size_;
     __compressed_pair<size_type, __storage_allocator> __cap_alloc_;
-
+public:
+    typedef __bit_reference<vector>                  reference;
+    typedef __bit_const_reference<vector>            const_reference;
+private:
     _LIBCPP_INLINE_VISIBILITY
     size_type& __cap() _NOEXCEPT
         {return __cap_alloc_.first();}
@@ -2063,7 +2070,7 @@ private:
     void __move_assign_alloc(const vector& __c, true_type)
         _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
         {
-            __alloc() = _STD::move(__c.__alloc());
+            __alloc() = _VSTD::move(__c.__alloc());
         }
 
     _LIBCPP_INLINE_VISIBILITY
@@ -2083,7 +2090,7 @@ private:
     static void __swap_alloc(__storage_allocator& __x, __storage_allocator& __y, true_type)
         _NOEXCEPT_(__is_nothrow_swappable<allocator_type>::value)
         {
-            using _STD::swap;
+            using _VSTD::swap;
             swap(__x, __y);
         }
     _LIBCPP_INLINE_VISIBILITY
@@ -2169,7 +2176,7 @@ vector<bool, _Allocator>::__recommend(size_type __new_size) const
     const size_type __cap = capacity();
     if (__cap >= __ms / 2)
         return __ms;
-    return _STD::max(2*__cap, __align(__new_size));
+    return _VSTD::max(2*__cap, __align(__new_size));
 }
 
 //  Default constructs __n objects starting at __end_
@@ -2183,7 +2190,7 @@ vector<bool, _Allocator>::__construct_at_end(size_type __n, bool __x)
 {
     size_type __old_size = this->__size_;
     this->__size_ += __n;
-    _STD::fill_n(__make_iter(__old_size), __n, __x);
+    _VSTD::fill_n(__make_iter(__old_size), __n, __x);
 }
 
 template <class _Allocator>
@@ -2196,8 +2203,8 @@ typename enable_if
 vector<bool, _Allocator>::__construct_at_end(_ForwardIterator __first, _ForwardIterator __last)
 {
     size_type __old_size = this->__size_;
-    this->__size_ += _STD::distance(__first, __last);
-    _STD::copy(__first, __last, __make_iter(__old_size));
+    this->__size_ += _VSTD::distance(__first, __last);
+    _VSTD::copy(__first, __last, __make_iter(__old_size));
 }
 
 template <class _Allocator>
@@ -2320,7 +2327,7 @@ vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __la
       __size_(0),
       __cap_alloc_(0)
 {
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         allocate(__n);
@@ -2336,7 +2343,7 @@ vector<bool, _Allocator>::vector(_ForwardIterator __first, _ForwardIterator __la
       __size_(0),
       __cap_alloc_(0, static_cast<__storage_allocator>(__a))
 {
-    size_type __n = static_cast<size_type>(_STD::distance(__first, __last));
+    size_type __n = static_cast<size_type>(_VSTD::distance(__first, __last));
     if (__n > 0)
     {
         allocate(__n);
@@ -2422,7 +2429,7 @@ vector<bool, _Allocator>::operator=(const vector& __v)
                 deallocate();
                 allocate(__v.__size_);
             }
-            _STD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
+            _VSTD::copy(__v.__begin_, __v.__begin_ + __external_cap_to_internal(__v.__size_), __begin_);
         }
         __size_ = __v.__size_;
     }
@@ -2520,7 +2527,7 @@ vector<bool, _Allocator>::assign(size_type __n, const value_type& __x)
             __v.__size_ = __n;
             swap(__v);
         }
-        _STD::fill_n(begin(), __n, __x);
+        _VSTD::fill_n(begin(), __n, __x);
     }
 }
 
@@ -2549,7 +2556,7 @@ typename enable_if
 vector<bool, _Allocator>::assign(_ForwardIterator __first, _ForwardIterator __last)
 {
     clear();
-    difference_type __n = _STD::distance(__first, __last);
+    difference_type __n = _VSTD::distance(__first, __last);
     if (__n)
     {
         if (__n > capacity())
@@ -2632,7 +2639,7 @@ vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __
     {
         const_iterator __old_end = end();
         ++__size_;
-        _STD::copy_backward(__position, __old_end, end());
+        _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
@@ -2640,8 +2647,8 @@ vector<bool, _Allocator>::insert(const_iterator __position, const value_type& __
         vector __v(__alloc());
         __v.reserve(__recommend(__size_ + 1));
         __v.__size_ = __size_ + 1;
-        __r = _STD::copy(cbegin(), __position, __v.begin());
-        _STD::copy_backward(__position, cend(), __v.end());
+        __r = _VSTD::copy(cbegin(), __position, __v.begin());
+        _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
     *__r = __x;
@@ -2658,7 +2665,7 @@ vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const
     {
         const_iterator __old_end = end();
         __size_ += __n;
-        _STD::copy_backward(__position, __old_end, end());
+        _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
@@ -2666,11 +2673,11 @@ vector<bool, _Allocator>::insert(const_iterator __position, size_type __n, const
         vector __v(__alloc());
         __v.reserve(__recommend(__size_ + __n));
         __v.__size_ = __size_ + __n;
-        __r = _STD::copy(cbegin(), __position, __v.begin());
-        _STD::copy_backward(__position, cend(), __v.end());
+        __r = _VSTD::copy(cbegin(), __position, __v.begin());
+        _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
-    _STD::fill_n(__r, __n, __x);
+    _VSTD::fill_n(__r, __n, __x);
     return __r;
 }
 
@@ -2714,7 +2721,7 @@ vector<bool, _Allocator>::insert(const_iterator __position, _InputIterator __fir
         }
 #endif  // _LIBCPP_NO_EXCEPTIONS
     }
-    __p = _STD::rotate(__p, __old_end, end());
+    __p = _VSTD::rotate(__p, __old_end, end());
     insert(__p, __v.begin(), __v.end());
     return begin() + __off;
 }
@@ -2728,14 +2735,14 @@ typename enable_if
 >::type
 vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __first, _ForwardIterator __last)
 {
-    difference_type __n = _STD::distance(__first, __last);
+    difference_type __n = _VSTD::distance(__first, __last);
     iterator __r;
     size_type __c = capacity();
     if (__n <= __c && size() <= __c - __n)
     {
         const_iterator __old_end = end();
         __size_ += __n;
-        _STD::copy_backward(__position, __old_end, end());
+        _VSTD::copy_backward(__position, __old_end, end());
         __r = __const_iterator_cast(__position);
     }
     else
@@ -2743,11 +2750,11 @@ vector<bool, _Allocator>::insert(const_iterator __position, _ForwardIterator __f
         vector __v(__alloc());
         __v.reserve(__recommend(__size_ + __n));
         __v.__size_ = __size_ + __n;
-        __r = _STD::copy(cbegin(), __position, __v.begin());
-        _STD::copy_backward(__position, cend(), __v.end());
+        __r = _VSTD::copy(cbegin(), __position, __v.begin());
+        _VSTD::copy_backward(__position, cend(), __v.end());
         swap(__v);
     }
-    _STD::copy(__first, __last, __r);
+    _VSTD::copy(__first, __last, __r);
     return __r;
 }
 
@@ -2757,7 +2764,7 @@ typename vector<bool, _Allocator>::iterator
 vector<bool, _Allocator>::erase(const_iterator __position)
 {
     iterator __r = __const_iterator_cast(__position);
-    _STD::copy(__position + 1, this->cend(), __r);
+    _VSTD::copy(__position + 1, this->cend(), __r);
     --__size_;
     return __r;
 }
@@ -2768,7 +2775,7 @@ vector<bool, _Allocator>::erase(const_iterator __first, const_iterator __last)
 {
     iterator __r = __const_iterator_cast(__first);
     difference_type __d = __last - __first;
-    _STD::copy(__last, this->cend(), __r);
+    _VSTD::copy(__last, this->cend(), __r);
     __size_ -= __d;
     return __r;
 }
@@ -2779,9 +2786,9 @@ vector<bool, _Allocator>::swap(vector& __x)
         _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value ||
                    __is_nothrow_swappable<allocator_type>::value)
 {
-    _STD::swap(this->__begin_, __x.__begin_);
-    _STD::swap(this->__size_, __x.__size_);
-    _STD::swap(this->__cap(), __x.__cap());
+    _VSTD::swap(this->__begin_, __x.__begin_);
+    _VSTD::swap(this->__size_, __x.__size_);
+    _VSTD::swap(this->__cap(), __x.__cap());
     __swap_alloc(this->__alloc(), __x.__alloc());
 #ifdef _LIBCPP_DEBUG
     iterator::swap(this, &__x);
@@ -2809,10 +2816,10 @@ vector<bool, _Allocator>::resize(size_type __sz, value_type __x)
             vector __v(__alloc());
             __v.reserve(__recommend(__size_ + __n));
             __v.__size_ = __size_ + __n;
-            __r = _STD::copy(cbegin(), cend(), __v.begin());
+            __r = _VSTD::copy(cbegin(), cend(), __v.begin());
             swap(__v);
         }
-        _STD::fill_n(__r, __n, __x);
+        _VSTD::fill_n(__r, __n, __x);
     }
     else
         __size_ = __sz;
@@ -2890,7 +2897,7 @@ bool
 operator==(const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
     const typename vector<_Tp, _Allocator>::size_type __sz = __x.size();
-    return __sz == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
+    return __sz == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
 }
 
 template <class _Tp, class _Allocator>
@@ -2906,7 +2913,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator< (const vector<_Tp, _Allocator>& __x, const vector<_Tp, _Allocator>& __y)
 {
-    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }
 
 template <class _Tp, class _Allocator>

src/future.cpp

@@ -59,6 +59,10 @@ future_error::future_error(error_code __ec)
 {
 }
 
+future_error::~future_error() _NOEXCEPT
+{
+}
+
 void
 __assoc_sub_state::__on_zero_shared() _NOEXCEPT
 {
@@ -69,8 +73,10 @@ void
 __assoc_sub_state::set_value()
 {
     unique_lock<mutex> __lk(__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
+#endif
     __state_ |= __constructed | ready;
     __lk.unlock();
     __cv_.notify_all();
@@ -80,8 +86,10 @@ void
 __assoc_sub_state::set_value_at_thread_exit()
 {
     unique_lock<mutex> __lk(__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
+#endif
     __state_ |= __constructed;
     __thread_local_data()->__make_ready_at_thread_exit(this);
     __lk.unlock();
@@ -91,8 +99,10 @@ void
 __assoc_sub_state::set_exception(exception_ptr __p)
 {
     unique_lock<mutex> __lk(__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
+#endif
     __exception_ = __p;
     __state_ |= ready;
     __lk.unlock();
@@ -103,8 +113,10 @@ void
 __assoc_sub_state::set_exception_at_thread_exit(exception_ptr __p)
 {
     unique_lock<mutex> __lk(__mut_);
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__has_value())
         throw future_error(make_error_code(future_errc::promise_already_satisfied));
+#endif
     __exception_ = __p;
     __thread_local_data()->__make_ready_at_thread_exit(this);
     __lk.unlock();
@@ -155,14 +167,18 @@ __assoc_sub_state::__sub_wait(unique_lock<mutex>& __lk)
 void
 __assoc_sub_state::__execute()
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     throw future_error(make_error_code(future_errc::no_state));
+#endif
 }
 
 future<void>::future(__assoc_sub_state* __state)
     : __state_(__state)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_->__has_future_attached())
         throw future_error(make_error_code(future_errc::future_already_retrieved));
+#endif
     __state_->__add_shared();
     __state_->__set_future_attached();
 }
@@ -202,40 +218,50 @@ promise<void>::~promise()
 future<void>
 promise<void>::get_future()
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     return future<void>(__state_);
 }
 
 void
 promise<void>::set_value()
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_value();
 }
 
 void
 promise<void>::set_exception(exception_ptr __p)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_exception(__p);
 }
 
 void
 promise<void>::set_value_at_thread_exit()
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_value_at_thread_exit();
 }
 
 void
 promise<void>::set_exception_at_thread_exit(exception_ptr __p)
 {
+#ifndef _LIBCPP_NO_EXCEPTIONS
     if (__state_ == nullptr)
         throw future_error(make_error_code(future_errc::no_state));
+#endif
     __state_->set_exception_at_thread_exit(__p);
 }
 

src/ios.cpp

@@ -165,7 +165,7 @@ ios_base::iword(int index)
         size_t newcap;
         const size_t mx = std::numeric_limits<size_t>::max();
         if (req_size < mx/2)
-            newcap = _STD::max(2 * __iarray_cap_, req_size);
+            newcap = _VSTD::max(2 * __iarray_cap_, req_size);
         else
             newcap = mx;
         long* iarray = (long*)realloc(__iarray_, newcap * sizeof(long));
@@ -193,7 +193,7 @@ ios_base::pword(int index)
         size_t newcap;
         const size_t mx = std::numeric_limits<size_t>::max();
         if (req_size < mx/2)
-            newcap = _STD::max(2 * __parray_cap_, req_size);
+            newcap = _VSTD::max(2 * __parray_cap_, req_size);
         else
             newcap = mx;
         void** parray = (void**)realloc(__parray_, newcap * sizeof(void*));
@@ -223,7 +223,7 @@ ios_base::register_callback(event_callback fn, int index)
         size_t newcap;
         const size_t mx = std::numeric_limits<size_t>::max();
         if (req_size < mx/2)
-            newcap = _STD::max(2 * __event_cap_, req_size);
+            newcap = _VSTD::max(2 * __event_cap_, req_size);
         else
             newcap = mx;
         event_callback* fns = (event_callback*)realloc(__fn_, newcap * sizeof(event_callback));
@@ -403,24 +403,24 @@ ios_base::move(ios_base& rhs)
 void
 ios_base::swap(ios_base& rhs)
 {
-    _STD::swap(__fmtflags_, rhs.__fmtflags_);
-    _STD::swap(__precision_, rhs.__precision_);
-    _STD::swap(__width_, rhs.__width_);
-    _STD::swap(__rdstate_, rhs.__rdstate_);
-    _STD::swap(__exceptions_, rhs.__exceptions_);
+    _VSTD::swap(__fmtflags_, rhs.__fmtflags_);
+    _VSTD::swap(__precision_, rhs.__precision_);
+    _VSTD::swap(__width_, rhs.__width_);
+    _VSTD::swap(__rdstate_, rhs.__rdstate_);
+    _VSTD::swap(__exceptions_, rhs.__exceptions_);
     locale& lhs_loc = *(locale*)&__loc_;
     locale& rhs_loc = *(locale*)&rhs.__loc_;
-    _STD::swap(lhs_loc, rhs_loc);
-    _STD::swap(__fn_, rhs.__fn_);
-    _STD::swap(__index_, rhs.__index_);
-    _STD::swap(__event_size_, rhs.__event_size_);
-    _STD::swap(__event_cap_, rhs.__event_cap_);
-    _STD::swap(__iarray_, rhs.__iarray_);
-    _STD::swap(__iarray_size_, rhs.__iarray_size_);
-    _STD::swap(__iarray_cap_, rhs.__iarray_cap_);
-    _STD::swap(__parray_, rhs.__parray_);
-    _STD::swap(__parray_size_, rhs.__parray_size_);
-    _STD::swap(__parray_cap_, rhs.__parray_cap_);
+    _VSTD::swap(lhs_loc, rhs_loc);
+    _VSTD::swap(__fn_, rhs.__fn_);
+    _VSTD::swap(__index_, rhs.__index_);
+    _VSTD::swap(__event_size_, rhs.__event_size_);
+    _VSTD::swap(__event_cap_, rhs.__event_cap_);
+    _VSTD::swap(__iarray_, rhs.__iarray_);
+    _VSTD::swap(__iarray_size_, rhs.__iarray_size_);
+    _VSTD::swap(__iarray_cap_, rhs.__iarray_cap_);
+    _VSTD::swap(__parray_, rhs.__parray_);
+    _VSTD::swap(__parray_size_, rhs.__parray_size_);
+    _VSTD::swap(__parray_cap_, rhs.__parray_cap_);
 }
 
 void

src/iostream.cpp

@@ -33,11 +33,11 @@ ios_base::Init __start_std_streams;
 ios_base::Init::Init()
 {
     cin.tie(&cout);
-    _STD::unitbuf(cerr);
+    _VSTD::unitbuf(cerr);
     cerr.tie(&cout);
 
     wcin.tie(&wcout);
-    _STD::unitbuf(wcerr);
+    _VSTD::unitbuf(wcerr);
     wcerr.tie(&wcout);
 }
 

src/locale.cpp

@@ -14,6 +14,7 @@
 #include "algorithm"
 #include "algorithm"
 #include "typeinfo"
+#include "type_traits"
 #include "clocale"
 #include "cstring"
 #include "cwctype"
@@ -21,8 +22,114 @@
 #include <langinfo.h>
 #include <stdlib.h>
 
+namespace {
+  typedef std::remove_pointer<locale_t>::type locale_struct;
+  typedef std::unique_ptr<locale_struct, decltype(&freelocale)> locale_unique_ptr;
+  typedef std::unique_ptr<locale_struct, decltype(&uselocale)> locale_raii;
+}
+
+namespace with_locale { namespace {
+#ifdef __APPLE__
+  using ::btowc_l;
+  using ::wctob_l;
+  using ::wcsnrtombs_l;
+  using ::wcrtomb_l;
+  using ::mbsnrtowcs_l;
+  using ::mbrtowc_l;
+  using ::mbtowc_l;
+  using ::mbrlen_l;
+  using ::localeconv_l;
+  using ::mbsrtowcs_l;
+
+  decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>()))
+  inline _LIBCPP_INLINE_VISIBILITY
+  mb_cur_max_l(locale_t loc)
+  {
+    return MB_CUR_MAX_L(loc);
+  }
+#else
+  template
+  <typename Function, typename ...Args>
+  auto using_locale(Function f, locale_t loc, Args&&... params) -> decltype(f(std::forward<Args>(params)...))
+  {
+    locale_raii current(uselocale(loc), uselocale);
+    return f(std::forward<Args>(params)...);
+  }
+
+  decltype(MB_CUR_MAX)
+  mb_cur_max_l(locale_t loc)
+  {
+    locale_raii current(uselocale(loc), uselocale);
+    return MB_CUR_MAX;
+  }
+
+  wint_t btowc_l(int c, locale_t l) { return using_locale(&btowc, l, c); }
+  int wctob_l(wint_t c, locale_t l) { return using_locale(&wctob, l, c); }
+  size_t wcsnrtombs_l(char * dest,
+                      const wchar_t * * src,
+                      size_t nwc,
+                      size_t len,
+                      mbstate_t * ps,
+                      locale_t l)
+  {
+    return using_locale(&wcsnrtombs, l, dest, src, nwc, len, ps);
+  }
+  size_t wcrtomb_l(char *s, wchar_t wc, mbstate_t *ps, locale_t l)
+  {
+    return using_locale(&wcrtomb, l, s, wc, ps);
+  }
+  size_t mbsnrtowcs_l(wchar_t * dest,
+                      const char * * src,
+                      size_t nms,
+                      size_t len,
+                      mbstate_t * ps,
+                      locale_t l)
+  {
+    return using_locale(&mbsnrtowcs, l, dest, src, nms, len, ps);
+  }
+  size_t mbrtowc_l(wchar_t *pwc, const char *s, size_t n, mbstate_t *ps, locale_t l)
+  {
+    return using_locale(&mbrtowc, l, pwc, s, n, ps);
+  }
+  int mbtowc_l(wchar_t * pwc, const char * pmb, size_t max, locale_t l)
+  {
+    return using_locale(&mbtowc, l, pwc, pmb, max);
+  }
+  size_t mbrlen_l(const char *s, size_t n, mbstate_t *ps, locale_t l)
+  {
+    return using_locale(&mbrlen, l, s, n, ps);
+  }
+  struct lconv *localeconv_l(locale_t l)
+  {
+    return using_locale(&localeconv, l);
+  }
+  size_t mbsrtowcs_l(wchar_t * dest,
+                     const char * * src,
+                     size_t len,
+                     mbstate_t * ps,
+                     locale_t l)
+  {
+    return using_locale(&mbsrtowcs, l, dest, src, len, ps);
+  }
+#endif
+} }
+
 _LIBCPP_BEGIN_NAMESPACE_STD
 
+#ifndef _LIBCPP_APPLE_STABLE_ABI
+locale_t __cloc() {
+  // In theory this could create a race condition. In practice
+  // the race condition is non-fatal since it will just create
+  // a little resource leak. Better approach would be appreciated.
+#ifdef __APPLE__
+  return 0;
+#else
+  static locale_t result = newlocale(LC_ALL_MASK, "C", 0);
+  return result;
+#endif
+}
+#endif // _LIBCPP_APPLE_STABLE_ABI
+
 namespace {
 
 struct release
@@ -95,10 +202,10 @@ locale::__imp::__imp(size_t refs)
       facets_(N)
 {
     facets_.clear();
-    install(&make<_STD::collate<char> >(1));
-    install(&make<_STD::collate<wchar_t> >(1));
-    install(&make<_STD::ctype<char> >((ctype_base::mask*)0, false, 1));
-    install(&make<_STD::ctype<wchar_t> >(1));
+    install(&make<_VSTD::collate<char> >(1));
+    install(&make<_VSTD::collate<wchar_t> >(1));
+    install(&make<_VSTD::ctype<char> >((ctype_base::mask*)0, false, 1));
+    install(&make<_VSTD::ctype<wchar_t> >(1));
     install(&make<codecvt<char, char, mbstate_t> >(1));
     install(&make<codecvt<wchar_t, char, mbstate_t> >(1));
     install(&make<codecvt<char16_t, char, mbstate_t> >(1));
@@ -121,8 +228,8 @@ locale::__imp::__imp(size_t refs)
     install(&make<time_get<wchar_t> >(1));
     install(&make<time_put<char> >(1));
     install(&make<time_put<wchar_t> >(1));
-    install(&make<_STD::messages<char> >(1));
-    install(&make<_STD::messages<wchar_t> >(1));
+    install(&make<_VSTD::messages<char> >(1));
+    install(&make<_VSTD::messages<wchar_t> >(1));
 }
 
 locale::__imp::__imp(const string& name, size_t refs)
@@ -265,17 +372,17 @@ locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
 #endif  // _LIBCPP_NO_EXCEPTIONS
         if (c & locale::collate)
         {
-            install_from<_STD::collate<char> >(one);
-            install_from<_STD::collate<wchar_t> >(one);
+            install_from<_VSTD::collate<char> >(one);
+            install_from<_VSTD::collate<wchar_t> >(one);
         }
         if (c & locale::ctype)
         {
-            install_from<_STD::ctype<char> >(one);
-            install_from<_STD::ctype<wchar_t> >(one);
-            install_from<_STD::codecvt<char, char, mbstate_t> >(one);
-            install_from<_STD::codecvt<char16_t, char, mbstate_t> >(one);
-            install_from<_STD::codecvt<char32_t, char, mbstate_t> >(one);
-            install_from<_STD::codecvt<wchar_t, char, mbstate_t> >(one);
+            install_from<_VSTD::ctype<char> >(one);
+            install_from<_VSTD::ctype<wchar_t> >(one);
+            install_from<_VSTD::codecvt<char, char, mbstate_t> >(one);
+            install_from<_VSTD::codecvt<char16_t, char, mbstate_t> >(one);
+            install_from<_VSTD::codecvt<char32_t, char, mbstate_t> >(one);
+            install_from<_VSTD::codecvt<wchar_t, char, mbstate_t> >(one);
         }
         if (c & locale::monetary)
         {
@@ -306,8 +413,8 @@ locale::__imp::__imp(const __imp& other, const __imp& one, locale::category c)
         }
         if (c & locale::messages)
         {
-            install_from<_STD::messages<char> >(one);
-            install_from<_STD::messages<wchar_t> >(one);
+            install_from<_VSTD::messages<char> >(one);
+            install_from<_VSTD::messages<wchar_t> >(one);
         }
 #ifndef _LIBCPP_NO_EXCEPTIONS
     }
@@ -674,93 +781,80 @@ ctype<wchar_t>::~ctype()
 bool
 ctype<wchar_t>::do_is(mask m, char_type c) const
 {
-#ifdef __APPLE__
-    return isascii(c) ? _DefaultRuneLocale.__runetype[c] & m : false;
-#else
-    return false;
-#endif
+    return isascii(c) ? ctype<char>::classic_table()[c] & m : false;
 }
 
 const wchar_t*
 ctype<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low, ++vec)
-        *vec = static_cast<mask>(isascii(*low) ? _DefaultRuneLocale.__runetype[*low] : 0);
+        *vec = static_cast<mask>(isascii(*low) ?
+                                   ctype<char>::classic_table()[*low] : 0);
     return low;
-#else
-    return NULL;
-#endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low)
-        if (isascii(*low) && (_DefaultRuneLocale.__runetype[*low] & m))
+        if (isascii(*low) && (ctype<char>::classic_table()[*low] & m))
             break;
     return low;
-#else
-    return NULL;
-#endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low)
-        if (!(isascii(*low) && (_DefaultRuneLocale.__runetype[*low] & m)))
+        if (!(isascii(*low) && (ctype<char>::classic_table()[*low] & m)))
             break;
     return low;
-#else
-    return NULL;
-#endif
 }
 
 wchar_t
 ctype<wchar_t>::do_toupper(char_type c) const
 {
-#ifdef __APPLE__
-    return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+    return isascii(c) ? ctype<char>::__classic_upper_table()[c] : c;
 #else
-    return 0;
+    return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
 #endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_toupper(char_type* low, const char_type* high) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low)
-        *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
-    return low;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+        *low = isascii(*low) ? ctype<char>::__classic_upper_table()[*low]
+                             : *low;
 #else
-    return NULL;
+        *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
 #endif
+    return low;
 }
 
 wchar_t
 ctype<wchar_t>::do_tolower(char_type c) const
 {
-#ifdef __APPLE__
-    return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+    return isascii(c) ? ctype<char>::__classic_lower_table()[c] : c;
 #else
-    return 0;
+    return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
 #endif
 }
 
 const wchar_t*
 ctype<wchar_t>::do_tolower(char_type* low, const char_type* high) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low)
-        *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
-    return low;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+        *low = isascii(*low) ? ctype<char>::__classic_lower_table()[*low]
+                             : *low;
 #else
-    return NULL;
+        *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
 #endif
+    return low;
 }
 
 wchar_t
@@ -805,10 +899,8 @@ ctype<char>::ctype(const mask* tab, bool del, size_t refs)
       __tab_(tab),
       __del_(del)
 {
-#ifdef __APPLE__
-    if (__tab_ == 0)
-        __tab_ = _DefaultRuneLocale.__runetype;
-#endif
+  if (__tab_ == 0)
+      __tab_ = classic_table();
 }
 
 ctype<char>::~ctype()
@@ -820,45 +912,45 @@ ctype<char>::~ctype()
 char
 ctype<char>::do_toupper(char_type c) const
 {
-#ifdef __APPLE__
-    return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+    return isascii(c) ? __classic_upper_table()[c] : c;
 #else
-    return 0;
+    return isascii(c) ? _DefaultRuneLocale.__mapupper[c] : c;
 #endif
 }
 
 const char*
 ctype<char>::do_toupper(char_type* low, const char_type* high) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low)
-        *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
-    return low;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+        *low = isascii(*low) ? __classic_upper_table()[*low] : *low;
 #else
-    return NULL;
+        *low = isascii(*low) ? _DefaultRuneLocale.__mapupper[*low] : *low;
 #endif
+    return low;
 }
 
 char
 ctype<char>::do_tolower(char_type c) const
 {
-#ifdef __APPLE__
-    return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+    return isascii(c) ? __classic_lower_table()[c] : c;
 #else
-    return 0;
+    return isascii(c) ? _DefaultRuneLocale.__maplower[c] : c;
 #endif
 }
 
 const char*
 ctype<char>::do_tolower(char_type* low, const char_type* high) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low)
-        *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
-    return low;
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+        *low = isascii(*low) ? __classic_lower_table()[*low] : *low;
 #else
-    return NULL;
+        *low = isascii(*low) ? _DefaultRuneLocale.__maplower[*low] : *low;
 #endif
+    return low;
 }
 
 char
@@ -899,11 +991,40 @@ ctype<char>::classic_table()  _NOEXCEPT
 {
 #ifdef __APPLE__
     return _DefaultRuneLocale.__runetype;
+#elif defined(__GLIBC__)
+    return __cloc()->__ctype_b;
+// This is assumed to be safe.
 #else
     return NULL;
 #endif
 }
 
+#ifndef _LIBCPP_STABLE_APPLE_ABI
+const int*
+ctype<char>::__classic_lower_table() _NOEXCEPT
+{
+#ifdef __APPLE__
+    return _DefaultRuneLocale.__maplower;
+#elif defined(__GLIBC__)
+    return __cloc()->__ctype_tolower;
+#else
+    return NULL;
+#endif
+}
+
+const int*
+ctype<char>::__classic_upper_table() _NOEXCEPT
+{
+#ifdef __APPLE__
+    return _DefaultRuneLocale.__mapupper;
+#elif defined(__GLIBC__)
+    return __cloc()->__ctype_toupper;
+#else
+    return NULL;
+#endif
+}
+#endif // _LIBCPP_APPLE_STABLE_ABI
+
 // template <> class ctype_byname<char>
 
 ctype_byname<char>::ctype_byname(const char* name, size_t refs)
@@ -993,17 +1114,30 @@ ctype_byname<wchar_t>::~ctype_byname()
 bool
 ctype_byname<wchar_t>::do_is(mask m, char_type c) const
 {
+#ifdef _LIBCPP_WCTYPE_IS_MASK
     return static_cast<bool>(iswctype_l(c, m, __l));
+#else
+    if (m & space && !iswspace_l(c, __l)) return false;
+    if (m & print && !iswprint_l(c, __l)) return false;
+    if (m & cntrl && !iswcntrl_l(c, __l)) return false;
+    if (m & upper && !iswupper_l(c, __l)) return false;
+    if (m & lower && !iswlower_l(c, __l)) return false;
+    if (m & alpha && !iswalpha_l(c, __l)) return false;
+    if (m & digit && !iswdigit_l(c, __l)) return false;
+    if (m & punct && !iswpunct_l(c, __l)) return false;
+    if (m & xdigit && !iswxdigit_l(c, __l)) return false;
+    if (m & blank && !iswblank_l(c, __l)) return false;
+    return true;
+#endif
 }
 
 const wchar_t*
 ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask* vec) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low, ++vec)
     {
         if (isascii(*low))
-            *vec = static_cast<mask>(_DefaultRuneLocale.__runetype[*low]);
+            *vec = static_cast<mask>(ctype<char>::classic_table()[*low]);
         else
         {
             *vec = 0;
@@ -1028,17 +1162,30 @@ ctype_byname<wchar_t>::do_is(const char_type* low, const char_type* high, mask*
         }
     }
     return low;
-#else
-    return NULL;
-#endif
 }
 
 const wchar_t*
 ctype_byname<wchar_t>::do_scan_is(mask m, const char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
+    {
+#ifdef _LIBCPP_WCTYPE_IS_MASK
         if (iswctype_l(*low, m, __l))
             break;
+#else
+        if (m & space && !iswspace_l(*low, __l)) continue;
+        if (m & print && !iswprint_l(*low, __l)) continue;
+        if (m & cntrl && !iswcntrl_l(*low, __l)) continue;
+        if (m & upper && !iswupper_l(*low, __l)) continue;
+        if (m & lower && !iswlower_l(*low, __l)) continue;
+        if (m & alpha && !iswalpha_l(*low, __l)) continue;
+        if (m & digit && !iswdigit_l(*low, __l)) continue;
+        if (m & punct && !iswpunct_l(*low, __l)) continue;
+        if (m & xdigit && !iswxdigit_l(*low, __l)) continue;
+        if (m & blank && !iswblank_l(*low, __l)) continue;
+        break;
+#endif
+    }
     return low;
 }
 
@@ -1046,8 +1193,24 @@ const wchar_t*
 ctype_byname<wchar_t>::do_scan_not(mask m, const char_type* low, const char_type* high) const
 {
     for (; low != high; ++low)
+    {
+#ifdef _LIBCPP_WCTYPE_IS_MASK
         if (!iswctype_l(*low, m, __l))
             break;
+#else
+        if (m & space && iswspace_l(*low, __l)) continue;
+        if (m & print && iswprint_l(*low, __l)) continue;
+        if (m & cntrl && iswcntrl_l(*low, __l)) continue;
+        if (m & upper && iswupper_l(*low, __l)) continue;
+        if (m & lower && iswlower_l(*low, __l)) continue;
+        if (m & alpha && iswalpha_l(*low, __l)) continue;
+        if (m & digit && iswdigit_l(*low, __l)) continue;
+        if (m & punct && iswpunct_l(*low, __l)) continue;
+        if (m & xdigit && iswxdigit_l(*low, __l)) continue;
+        if (m & blank && iswblank_l(*low, __l)) continue;
+        break;
+#endif
+    }
     return low;
 }
 
@@ -1082,49 +1245,33 @@ ctype_byname<wchar_t>::do_tolower(char_type* low, const char_type* high) const
 wchar_t
 ctype_byname<wchar_t>::do_widen(char c) const
 {
-#ifdef __APPLE__
-    return btowc_l(c, __l);
-#else
-    return 0;
-#endif
+    return with_locale::btowc_l(c, __l);
 }
 
 const char*
 ctype_byname<wchar_t>::do_widen(const char* low, const char* high, char_type* dest) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low, ++dest)
-        *dest = btowc_l(*low, __l);
+        *dest = with_locale::btowc_l(*low, __l);
     return low;
-#else
-    return NULL;
-#endif
 }
 
 char
 ctype_byname<wchar_t>::do_narrow(char_type c, char dfault) const
 {
-#ifdef __APPLE__
-    int r = wctob_l(c, __l);
+    int r = with_locale::wctob_l(c, __l);
     return r != WEOF ? static_cast<char>(r) : dfault;
-#else
-    return 0;
-#endif
 }
 
 const wchar_t*
 ctype_byname<wchar_t>::do_narrow(const char_type* low, const char_type* high, char dfault, char* dest) const
 {
-#ifdef __APPLE__
     for (; low != high; ++low, ++dest)
     {
-        int r = wctob_l(*low, __l);
+        int r = with_locale::wctob_l(*low, __l);
         *dest = r != WEOF ? static_cast<char>(r) : dfault;
     }
     return low;
-#else
-    return NULL;
-#endif
 }
 
 // template <> class codecvt<char, char, mbstate_t>
@@ -1220,7 +1367,6 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
     const intern_type* frm, const intern_type* frm_end, const intern_type*& frm_nxt,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-#ifdef __APPLE__
     // look for first internal null in frm
     const intern_type* fend = frm;
     for (; fend != frm_end; ++fend)
@@ -1232,13 +1378,13 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
     {
         // save state in case needed to reover to_nxt on error
         mbstate_t save_state = st;
-        size_t n = wcsnrtombs_l(to, &frm_nxt, fend-frm, to_end-to, &st, __l);
+        size_t n = with_locale::wcsnrtombs_l(to, &frm_nxt, fend-frm, to_end-to, &st, __l);
         if (n == size_t(-1))
         {
             // need to recover to_nxt
             for (to_nxt = to; frm != frm_nxt; ++frm)
             {
-                n = wcrtomb_l(to_nxt, *frm, &save_state, __l);
+                n = with_locale::wcrtomb_l(to_nxt, *frm, &save_state, __l);
                 if (n == size_t(-1))
                     break;
                 to_nxt += n;
@@ -1255,7 +1401,7 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
         {
             // Try to write the terminating null
             extern_type tmp[MB_LEN_MAX];
-            n = wcrtomb_l(tmp, intern_type(), &st, __l);
+            n = with_locale::wcrtomb_l(tmp, intern_type(), &st, __l);
             if (n == size_t(-1))  // on error
                 return error;
             if (n > to_end-to_nxt)  // is there room?
@@ -1270,9 +1416,6 @@ codecvt<wchar_t, char, mbstate_t>::do_out(state_type& st,
         }
     }
     return frm_nxt == frm_end ? ok : partial;
-#else
-    return error;
-#endif
 }
 
 codecvt<wchar_t, char, mbstate_t>::result
@@ -1280,7 +1423,6 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
     const extern_type* frm, const extern_type* frm_end, const extern_type*& frm_nxt,
     intern_type* to, intern_type* to_end, intern_type*& to_nxt) const
 {
-#ifdef __APPLE__
     // look for first internal null in frm
     const extern_type* fend = frm;
     for (; fend != frm_end; ++fend)
@@ -1292,13 +1434,13 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
     {
         // save state in case needed to reover to_nxt on error
         mbstate_t save_state = st;
-        size_t n = mbsnrtowcs_l(to, &frm_nxt, fend-frm, to_end-to, &st, __l);
+        size_t n = with_locale::mbsnrtowcs_l(to, &frm_nxt, fend-frm, to_end-to, &st, __l);
         if (n == size_t(-1))
         {
             // need to recover to_nxt
             for (to_nxt = to; frm != frm_nxt; ++to_nxt)
             {
-                n = mbrtowc_l(to_nxt, frm, fend-frm, &save_state, __l);
+                n = with_locale::mbrtowc_l(to_nxt, frm, fend-frm, &save_state, __l);
                 switch (n)
                 {
                 case 0:
@@ -1326,7 +1468,7 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
         if (fend != frm_end)  // set up next null terminated sequence
         {
             // Try to write the terminating null
-            n = mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
+            n = with_locale::mbrtowc_l(to_nxt, frm_nxt, 1, &st, __l);
             if (n != 0)  // on error
                 return error;
             ++to_nxt;
@@ -1338,19 +1480,15 @@ codecvt<wchar_t, char, mbstate_t>::do_in(state_type& st,
         }
     }
     return frm_nxt == frm_end ? ok : partial;
-#else
-    return error;
-#endif
 }
 
 codecvt<wchar_t, char, mbstate_t>::result
 codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
     extern_type* to, extern_type* to_end, extern_type*& to_nxt) const
 {
-#ifdef __APPLE__
     to_nxt = to;
     extern_type tmp[MB_LEN_MAX];
-    size_t n = wcrtomb_l(tmp, intern_type(), &st, __l);
+    size_t n = with_locale::wcrtomb_l(tmp, intern_type(), &st, __l);
     if (n == size_t(-1) || n == 0)  // on error
         return error;
     --n;
@@ -1359,26 +1497,19 @@ codecvt<wchar_t, char, mbstate_t>::do_unshift(state_type& st,
     for (extern_type* p = tmp; n; --n)  // write it
         *to_nxt++ = *p++;
     return ok;
-#else
-    return error;
-#endif
 }
 
 int
 codecvt<wchar_t, char, mbstate_t>::do_encoding() const  _NOEXCEPT
 {
-#ifdef __APPLE__
-    if (mbtowc_l(0, 0, MB_LEN_MAX, __l) == 0)
+    if (with_locale::mbtowc_l((wchar_t*) 0, (const char*) 0, MB_LEN_MAX, __l) == 0)
     {
         // stateless encoding
-        if (__l == 0 || MB_CUR_MAX_L(__l) == 1)  // there are no known constant length encodings
+        if (__l == 0 || with_locale::mb_cur_max_l(__l) == 1)  // there are no known constant length encodings
             return 1;                // which take more than 1 char to form a wchar_t
          return 0;
     }
     return -1;
-#else
-    return 0;
-#endif
 }
 
 bool
@@ -1391,11 +1522,10 @@ int
 codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
     const extern_type* frm, const extern_type* frm_end, size_t mx) const
 {
-#ifdef __APPLE__
     int nbytes = 0;
     for (size_t nwchar_t = 0; nwchar_t < mx && frm != frm_end; ++nwchar_t)
     {
-        size_t n = mbrlen_l(frm, frm_end-frm, &st, __l);
+        size_t n = with_locale::mbrlen_l(frm, frm_end-frm, &st, __l);
         switch (n)
         {
         case 0:
@@ -1412,19 +1542,12 @@ codecvt<wchar_t, char, mbstate_t>::do_length(state_type& st,
         }
     }
     return nbytes;
-#else
-    return 0;
-#endif
 }
 
 int
 codecvt<wchar_t, char, mbstate_t>::do_max_length() const  _NOEXCEPT
 {
-#ifdef __APPLE__
-    return __l == 0 ? 1 : MB_CUR_MAX_L(__l);
-#else
-    return 0;
-#endif
+    return __l == 0 ? 1 : with_locale::mb_cur_max_l(__l);
 }
 
 //                                     Valid UTF ranges
@@ -3965,24 +4088,22 @@ numpunct_byname<char>::~numpunct_byname()
 void
 numpunct_byname<char>::__init(const char* nm)
 {
-#ifdef __APPLE__
     if (strcmp(nm, "C") != 0)
     {
-        unique_ptr<_xlocale, int(*)(locale_t)>  loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+        locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         if (loc == 0)
             throw runtime_error("numpunct_byname<char>::numpunct_byname"
                                 " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        lconv* lc = localeconv_l(loc.get());
+        lconv* lc = with_locale::localeconv_l(loc.get());
         if (*lc->decimal_point)
             __decimal_point_ = *lc->decimal_point;
         if (*lc->thousands_sep)
             __thousands_sep_ = *lc->thousands_sep;
         __grouping_ = lc->grouping;
-        // locallization for truename and falsename is not available
+        // localization for truename and falsename is not available
     }
-#endif
 }
 
 // numpunct_byname<wchar_t>
@@ -4006,16 +4127,15 @@ numpunct_byname<wchar_t>::~numpunct_byname()
 void
 numpunct_byname<wchar_t>::__init(const char* nm)
 {
-#ifdef __APPLE__
     if (strcmp(nm, "C") != 0)
     {
-        unique_ptr<_xlocale, int(*)(locale_t)>  loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+        locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
         if (loc == 0)
             throw runtime_error("numpunct_byname<char>::numpunct_byname"
                                 " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        lconv* lc = localeconv_l(loc.get());
+        lconv* lc = with_locale::localeconv_l(loc.get());
         if (*lc->decimal_point)
             __decimal_point_ = *lc->decimal_point;
         if (*lc->thousands_sep)
@@ -4023,7 +4143,6 @@ numpunct_byname<wchar_t>::__init(const char* nm)
         __grouping_ = lc->grouping;
         // locallization for truename and falsename is not available
     }
-#endif
 }
 
 // num_get helpers
@@ -4588,7 +4707,6 @@ template <>
 wstring
 __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
 {
-#ifdef __APPLE__
     tm t;
     t.tm_sec = 59;
     t.tm_min = 55;
@@ -4608,7 +4726,7 @@ __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
     wchar_t* wbb = wbuf;
     mbstate_t mb = {0};
     const char* bb = buf;
-    size_t i = mbsrtowcs_l(wbb, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+    size_t i = with_locale::mbsrtowcs_l( wbb, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
     if (i == -1)
         __throw_runtime_error("locale not supported");
     wchar_t* wbe = wbb + i;
@@ -4733,9 +4851,6 @@ __time_get_storage<wchar_t>::__analyze(char fmt, const ctype<wchar_t>& ct)
         ++wbb;
     }
     return result;
-#else
-    return wstring();
-#endif
 }
 
 template <>
@@ -4779,7 +4894,6 @@ template <>
 void
 __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
 {
-#ifdef __APPLE__
     tm t = {0};
     char buf[100];
     size_t be;
@@ -4793,7 +4907,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         be = strftime_l(buf, 100, "%A", &t, __loc_);
         mb = mbstate_t();
         const char* bb = buf;
-        size_t j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+        size_t j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -4801,7 +4915,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         be = strftime_l(buf, 100, "%a", &t, __loc_);
         mb = mbstate_t();
         bb = buf;
-        j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+        j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -4814,7 +4928,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         be = strftime_l(buf, 100, "%B", &t, __loc_);
         mb = mbstate_t();
         const char* bb = buf;
-        size_t j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+        size_t j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -4822,7 +4936,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
         be = strftime_l(buf, 100, "%b", &t, __loc_);
         mb = mbstate_t();
         bb = buf;
-        j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+        j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -4833,7 +4947,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
     be = strftime_l(buf, 100, "%p", &t, __loc_);
     mb = mbstate_t();
     const char* bb = buf;
-    size_t j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+    size_t j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
     if (j == -1)
         __throw_runtime_error("locale not supported");
     wbe = wbuf + j;
@@ -4842,7 +4956,7 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
     be = strftime_l(buf, 100, "%p", &t, __loc_);
     mb = mbstate_t();
     bb = buf;
-    j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
+    j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, __loc_);
     if (j == -1)
         __throw_runtime_error("locale not supported");
     wbe = wbuf + j;
@@ -4851,7 +4965,6 @@ __time_get_storage<wchar_t>::init(const ctype<wchar_t>& ct)
     __r_ = __analyze('r', ct);
     __x_ = __analyze('x', ct);
     __X_ = __analyze('X', ct);
-#endif
 }
 
 template <class CharT>
@@ -5113,17 +5226,15 @@ void
 __time_put::__do_put(wchar_t* __wb, wchar_t*& __we, const tm* __tm,
                      char __fmt, char __mod) const
 {
-#ifdef __APPLE__
     char __nar[100];
     char* __ne = __nar + 100;
     __do_put(__nar, __ne, __tm, __fmt, __mod);
     mbstate_t mb = {0};
     const char* __nb = __nar;
-    size_t j = mbsrtowcs_l(__wb, &__nb, 100, &mb, __loc_);
+    size_t j = with_locale::mbsrtowcs_l(__wb, &__nb, 100, &mb, __loc_);
     if (j == -1)
         __throw_runtime_error("locale not supported");
     __we = __wb + j;
-#endif
 }
 
 // moneypunct_byname
@@ -5368,15 +5479,14 @@ template<>
 void
 moneypunct_byname<char, false>::init(const char* nm)
 {
-#ifdef __APPLE__
     typedef moneypunct<char, false> base;
-    unique_ptr<_xlocale, int(*)(locale_t)>  loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == 0)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    lconv* lc = localeconv_l(loc.get());
+    lconv* lc = with_locale::localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = *lc->mon_decimal_point;
     else
@@ -5401,22 +5511,20 @@ moneypunct_byname<char, false>::init(const char* nm)
         __negative_sign_ = lc->negative_sign;
     __init_pat(__pos_format_, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn);
     __init_pat(__neg_format_, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn);
-#endif
 }
 
 template<>
 void
 moneypunct_byname<char, true>::init(const char* nm)
 {
-#ifdef __APPLE__
     typedef moneypunct<char, true> base;
-    unique_ptr<_xlocale, int(*)(locale_t)>  loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == 0)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    lconv* lc = localeconv_l(loc.get());
+    lconv* lc = with_locale::localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = *lc->mon_decimal_point;
     else
@@ -5441,22 +5549,20 @@ moneypunct_byname<char, true>::init(const char* nm)
         __negative_sign_ = lc->negative_sign;
     __init_pat(__pos_format_, lc->int_p_cs_precedes, lc->int_p_sep_by_space, lc->int_p_sign_posn);
     __init_pat(__neg_format_, lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_sign_posn);
-#endif
 }
 
 template<>
 void
 moneypunct_byname<wchar_t, false>::init(const char* nm)
 {
-#ifdef __APPLE__
     typedef moneypunct<wchar_t, false> base;
-    unique_ptr<_xlocale, int(*)(locale_t)>  loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == 0)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    lconv* lc = localeconv_l(loc.get());
+    lconv* lc = with_locale::localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);
     else
@@ -5469,7 +5575,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     wchar_t wbuf[100];
     mbstate_t mb = {0};
     const char* bb = lc->currency_symbol;
-    size_t j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
+    size_t j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
     if (j == -1)
         __throw_runtime_error("locale not supported");
     wchar_t* wbe = wbuf + j;
@@ -5484,7 +5590,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->positive_sign;
-        j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
+        j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5496,7 +5602,7 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->negative_sign;
-        j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
+        j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5504,22 +5610,20 @@ moneypunct_byname<wchar_t, false>::init(const char* nm)
     }
     __init_pat(__pos_format_, lc->p_cs_precedes, lc->p_sep_by_space, lc->p_sign_posn);
     __init_pat(__neg_format_, lc->n_cs_precedes, lc->n_sep_by_space, lc->n_sign_posn);
-#endif
 }
 
 template<>
 void
 moneypunct_byname<wchar_t, true>::init(const char* nm)
 {
-#ifdef __APPLE__
     typedef moneypunct<wchar_t, true> base;
-    unique_ptr<_xlocale, int(*)(locale_t)>  loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
+    locale_unique_ptr loc(newlocale(LC_ALL_MASK, nm, 0), freelocale);
 #ifndef _LIBCPP_NO_EXCEPTIONS
     if (loc == 0)
         throw runtime_error("moneypunct_byname"
                             " failed to construct for " + string(nm));
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    lconv* lc = localeconv_l(loc.get());
+    lconv* lc = with_locale::localeconv_l(loc.get());
     if (*lc->mon_decimal_point)
         __decimal_point_ = static_cast<wchar_t>(*lc->mon_decimal_point);
     else
@@ -5532,7 +5636,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     wchar_t wbuf[100];
     mbstate_t mb = {0};
     const char* bb = lc->int_curr_symbol;
-    size_t j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
+    size_t j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
     if (j == -1)
         __throw_runtime_error("locale not supported");
     wchar_t* wbe = wbuf + j;
@@ -5547,7 +5651,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->positive_sign;
-        j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
+        j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5559,7 +5663,7 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     {
         mb = mbstate_t();
         bb = lc->negative_sign;
-        j = mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
+        j = with_locale::mbsrtowcs_l(wbuf, &bb, sizeof(wbuf)/sizeof(wbuf[0]), &mb, loc.get());
         if (j == -1)
             __throw_runtime_error("locale not supported");
         wbe = wbuf + j;
@@ -5567,7 +5671,6 @@ moneypunct_byname<wchar_t, true>::init(const char* nm)
     }
     __init_pat(__pos_format_, lc->int_p_cs_precedes, lc->int_p_sep_by_space, lc->int_p_sign_posn);
     __init_pat(__neg_format_, lc->int_n_cs_precedes, lc->int_n_sep_by_space, lc->int_n_sign_posn);
-#endif
 }
 
 void __do_nothing(void*) {}

src/new.cpp

@@ -28,6 +28,9 @@
 __attribute__((__weak__, __visibility__("default")))
 void *
 operator new(std::size_t size)
+#if !__has_feature(cxx_noexcept)
+    throw(std::bad_alloc)
+#endif
 {
     if (size == 0)
         size = 1;
@@ -71,6 +74,9 @@ operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
 __attribute__((__weak__, __visibility__("default")))
 void*
 operator new[](size_t size)
+#if !__has_feature(cxx_noexcept)
+    throw(std::bad_alloc)
+#endif
 {
     return ::operator new(size);
 }

src/regex.cpp

@@ -229,7 +229,7 @@ string
 __get_collation_name(const char* s)
 {
     const collationnames* i =
-            _STD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
+            _VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
     string r;
     if (i != end(collatenames) && strcmp(s, i->elem_) == 0)
         r = char(i->char_);
@@ -240,7 +240,7 @@ ctype_base::mask
 __get_classname(const char* s, bool __icase)
 {
     const classnames* i =
-            _STD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
+            _VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
     ctype_base::mask r = 0;
     if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)
     {

src/string.cpp

@@ -19,52 +19,6 @@ template class __basic_string_common<true>;
 template class basic_string<char>;
 template class basic_string<wchar_t>;
 
-template enable_if<__is_forward_iterator<char const*>::value, void>::type
-    basic_string<char, char_traits<char>, allocator<char> >
-    ::__init<char const*>(char const*, char const*);
-
-template enable_if<__is_forward_iterator<wchar_t const*>::value, void>::type
-    basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >
-    ::__init<wchar_t const*>(wchar_t const*, wchar_t const*);
-
-template
-    enable_if<__is_forward_iterator<char*>::value,
-    basic_string<char, char_traits<char>, allocator<char> >&>::type
-    basic_string<char, char_traits<char>, allocator<char> >::
-    append<char*>(char*, char*);
-
-template
-    enable_if<__is_forward_iterator<wchar_t*>::value,
-    basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >&>::type
-    basic_string<wchar_t, char_traits<wchar_t>, allocator<wchar_t> >::
-    append<wchar_t*>(wchar_t*, wchar_t*);
-
-template
-    enable_if<__is_forward_iterator<char const*>::value,
-    string::iterator>::type
-    string::
-    insert<char const*>(string::const_iterator, char const*, char const*);
-
-template
-    enable_if<__is_forward_iterator<wchar_t const*>::value,
-    wstring::iterator>::type
-    wstring::
-    insert<wchar_t const*>(wstring::const_iterator, wchar_t const*, wchar_t const*);
-
-template
-    enable_if<__is_input_iterator<char const*>::value, string&>::type
-    string::
-    replace<char const*>(string::const_iterator, string::const_iterator, char const*, char const*);
-
-template
-    enable_if<__is_input_iterator<wchar_t const*>::value, wstring&>::type
-    wstring::
-    replace<wchar_t const*>(wstring::const_iterator, wstring::const_iterator, wchar_t const*, wchar_t const*);
-
-template
-    enable_if<__is_forward_iterator<wchar_t*>::value, wstring&>::type
-    wstring::assign<wchar_t*>(wchar_t*, wchar_t*);
-
 template
     string
     operator+<char, char_traits<char>, allocator<char> >(char const*, string const&);

src/strstream.cpp

@@ -100,41 +100,6 @@ strstreambuf::strstreambuf(const unsigned char* __gnext, streamsize __n)
     __init((char*)__gnext, __n, nullptr);
 }
 
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-strstreambuf::strstreambuf(strstreambuf&& __rhs)
-    : streambuf(__rhs),
-      __strmode_(__rhs.__strmode_),
-      __alsize_(__rhs.__alsize_),
-      __palloc_(__rhs.__palloc_),
-      __pfree_(__rhs.__pfree_)
-{
-    __rhs.setg(nullptr, nullptr, nullptr);
-    __rhs.setp(nullptr, nullptr);
-}
-
-strstreambuf&
-strstreambuf::operator=(strstreambuf&& __rhs)
-{
-    if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
-    {
-        if (__pfree_)
-            __pfree_(eback());
-        else
-            delete [] eback();
-    }
-    streambuf::operator=(__rhs);
-    __strmode_ = __rhs.__strmode_;
-    __alsize_ = __rhs.__alsize_;
-    __palloc_ = __rhs.__palloc_;
-    __pfree_ = __rhs.__pfree_;
-    __rhs.setg(nullptr, nullptr, nullptr);
-    __rhs.setp(nullptr, nullptr);
-    return *this;
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 strstreambuf::~strstreambuf()
 {
     if (eback() && (__strmode_ & __allocated) != 0 && (__strmode_ & __frozen) == 0)
@@ -150,10 +115,10 @@ void
 strstreambuf::swap(strstreambuf& __rhs)
 {
     streambuf::swap(__rhs);
-    _STD::swap(__strmode_, __rhs.__strmode_);
-    _STD::swap(__alsize_, __rhs.__alsize_);
-    _STD::swap(__palloc_, __rhs.__palloc_);
-    _STD::swap(__pfree_, __rhs.__pfree_);
+    _VSTD::swap(__strmode_, __rhs.__strmode_);
+    _VSTD::swap(__alsize_, __rhs.__alsize_);
+    _VSTD::swap(__palloc_, __rhs.__palloc_);
+    _VSTD::swap(__pfree_, __rhs.__pfree_);
 }
 
 void
@@ -302,7 +267,7 @@ strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmod
         {
             char* newpos = eback() + newoff;
             if (pos_in)
-                setg(eback(), newpos, _STD::max(newpos, egptr()));
+                setg(eback(), newpos, _VSTD::max(newpos, egptr()));
             if (pos_out)
             {
                 // min(pbase, newpos), newpos, epptr()
@@ -332,7 +297,7 @@ strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
             {
                 char* newpos = eback() + newoff;
                 if (pos_in)
-                    setg(eback(), newpos, _STD::max(newpos, egptr()));
+                    setg(eback(), newpos, _VSTD::max(newpos, egptr()));
                 if (pos_out)
                 {
                     // min(pbase, newpos), newpos, epptr()

src/system_error.cpp

@@ -147,7 +147,7 @@ system_error::__init(const error_code& ec, string what_arg)
             what_arg += ": ";
         what_arg += ec.message();
     }
-    return _STD::move(what_arg);
+    return _VSTD::move(what_arg);
 }
 
 system_error::system_error(error_code ec, const string& what_arg)

test/depr/depr.c.headers/inttypes_h.pass.cpp

@@ -12,250 +12,6 @@
 #include <inttypes.h>
 #include <type_traits>
 
-#ifndef INT8_MIN
-#error INT8_MIN not defined
-#endif
-
-#ifndef INT16_MIN
-#error INT16_MIN not defined
-#endif
-
-#ifndef INT32_MIN
-#error INT32_MIN not defined
-#endif
-
-#ifndef INT64_MIN
-#error INT64_MIN not defined
-#endif
-
-#ifndef INT8_MAX
-#error INT8_MAX not defined
-#endif
-
-#ifndef INT16_MAX
-#error INT16_MAX not defined
-#endif
-
-#ifndef INT32_MAX
-#error INT32_MAX not defined
-#endif
-
-#ifndef INT64_MAX
-#error INT64_MAX not defined
-#endif
-
-#ifndef UINT8_MAX
-#error UINT8_MAX not defined
-#endif
-
-#ifndef UINT16_MAX
-#error UINT16_MAX not defined
-#endif
-
-#ifndef UINT32_MAX
-#error UINT32_MAX not defined
-#endif
-
-#ifndef UINT64_MAX
-#error UINT64_MAX not defined
-#endif
-
-#ifndef INT_LEAST8_MIN
-#error INT_LEAST8_MIN not defined
-#endif
-
-#ifndef INT_LEAST16_MIN
-#error INT_LEAST16_MIN not defined
-#endif
-
-#ifndef INT_LEAST32_MIN
-#error INT_LEAST32_MIN not defined
-#endif
-
-#ifndef INT_LEAST64_MIN
-#error INT_LEAST64_MIN not defined
-#endif
-
-#ifndef INT_LEAST8_MAX
-#error INT_LEAST8_MAX not defined
-#endif
-
-#ifndef INT_LEAST16_MAX
-#error INT_LEAST16_MAX not defined
-#endif
-
-#ifndef INT_LEAST32_MAX
-#error INT_LEAST32_MAX not defined
-#endif
-
-#ifndef INT_LEAST64_MAX
-#error INT_LEAST64_MAX not defined
-#endif
-
-#ifndef UINT_LEAST8_MAX
-#error UINT_LEAST8_MAX not defined
-#endif
-
-#ifndef UINT_LEAST16_MAX
-#error UINT_LEAST16_MAX not defined
-#endif
-
-#ifndef UINT_LEAST32_MAX
-#error UINT_LEAST32_MAX not defined
-#endif
-
-#ifndef UINT_LEAST64_MAX
-#error UINT_LEAST64_MAX not defined
-#endif
-
-#ifndef INT_FAST8_MIN
-#error INT_FAST8_MIN not defined
-#endif
-
-#ifndef INT_FAST16_MIN
-#error INT_FAST16_MIN not defined
-#endif
-
-#ifndef INT_FAST32_MIN
-#error INT_FAST32_MIN not defined
-#endif
-
-#ifndef INT_FAST64_MIN
-#error INT_FAST64_MIN not defined
-#endif
-
-#ifndef INT_FAST8_MAX
-#error INT_FAST8_MAX not defined
-#endif
-
-#ifndef INT_FAST16_MAX
-#error INT_FAST16_MAX not defined
-#endif
-
-#ifndef INT_FAST32_MAX
-#error INT_FAST32_MAX not defined
-#endif
-
-#ifndef INT_FAST64_MAX
-#error INT_FAST64_MAX not defined
-#endif
-
-#ifndef UINT_FAST8_MAX
-#error UINT_FAST8_MAX not defined
-#endif
-
-#ifndef UINT_FAST16_MAX
-#error UINT_FAST16_MAX not defined
-#endif
-
-#ifndef UINT_FAST32_MAX
-#error UINT_FAST32_MAX not defined
-#endif
-
-#ifndef UINT_FAST64_MAX
-#error UINT_FAST64_MAX not defined
-#endif
-
-#ifndef INTPTR_MIN
-#error INTPTR_MIN not defined
-#endif
-
-#ifndef INTPTR_MAX
-#error INTPTR_MAX not defined
-#endif
-
-#ifndef UINTPTR_MAX
-#error UINTPTR_MAX not defined
-#endif
-
-#ifndef INTMAX_MIN
-#error INTMAX_MIN not defined
-#endif
-
-#ifndef INTMAX_MAX
-#error INTMAX_MAX not defined
-#endif
-
-#ifndef UINTMAX_MAX
-#error UINTMAX_MAX not defined
-#endif
-
-#ifndef PTRDIFF_MIN
-#error PTRDIFF_MIN not defined
-#endif
-
-#ifndef PTRDIFF_MAX
-#error PTRDIFF_MAX not defined
-#endif
-
-#ifndef SIG_ATOMIC_MIN
-#error SIG_ATOMIC_MIN not defined
-#endif
-
-#ifndef SIG_ATOMIC_MAX
-#error SIG_ATOMIC_MAX not defined
-#endif
-
-#ifndef SIZE_MAX
-#error SIZE_MAX not defined
-#endif
-
-#ifndef WCHAR_MIN
-#error WCHAR_MIN not defined
-#endif
-
-#ifndef WCHAR_MAX
-#error WCHAR_MAX not defined
-#endif
-
-#ifndef WINT_MIN
-#error WINT_MIN not defined
-#endif
-
-#ifndef WINT_MAX
-#error WINT_MAX not defined
-#endif
-
-#ifndef INT8_C
-#error INT8_C not defined
-#endif
-
-#ifndef INT16_C
-#error INT16_C not defined
-#endif
-
-#ifndef INT32_C
-#error INT32_C not defined
-#endif
-
-#ifndef INT64_C
-#error INT64_C not defined
-#endif
-
-#ifndef UINT8_C
-#error UINT8_C not defined
-#endif
-
-#ifndef UINT16_C
-#error UINT16_C not defined
-#endif
-
-#ifndef UINT32_C
-#error UINT32_C not defined
-#endif
-
-#ifndef UINT64_C
-#error UINT64_C not defined
-#endif
-
-#ifndef INTMAX_C
-#error INTMAX_C not defined
-#endif
-
-#ifndef UINTMAX_C
-#error UINTMAX_C not defined
-#endif
-
 #ifndef PRId8
 #error PRId8 not defined
 #endif
@@ -874,48 +630,6 @@
 
 int main()
 {
-    {
-    int8_t  i1 = 0;
-    int16_t i2 = 0;
-    int32_t i3 = 0;
-    int64_t i4 = 0;
-    }
-    {
-    uint8_t  i1 = 0;
-    uint16_t i2 = 0;
-    uint32_t i3 = 0;
-    uint64_t i4 = 0;
-    }
-    {
-    int_least8_t  i1 = 0;
-    int_least16_t i2 = 0;
-    int_least32_t i3 = 0;
-    int_least64_t i4 = 0;
-    }
-    {
-    uint_least8_t  i1 = 0;
-    uint_least16_t i2 = 0;
-    uint_least32_t i3 = 0;
-    uint_least64_t i4 = 0;
-    }
-    {
-    int_fast8_t  i1 = 0;
-    int_fast16_t i2 = 0;
-    int_fast32_t i3 = 0;
-    int_fast64_t i4 = 0;
-    }
-    {
-    uint_fast8_t  i1 = 0;
-    uint_fast16_t i2 = 0;
-    uint_fast32_t i3 = 0;
-    uint_fast64_t i4 = 0;
-    }
-    {
-    intptr_t  i1 = 0;
-    uintptr_t i2 = 0;
-    intmax_t  i3 = 0;
-    uintmax_t i4 = 0;
-    }
     {
     imaxdiv_t  i1 = {0};
     }

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy.pass.cpp

@@ -107,7 +107,7 @@ int main()
     assert(new_called == 1);
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
-    std::function<int(int)> f2 = _STD::move(f);
+    std::function<int(int)> f2 = std::move(f);
     assert(A::count == 1);
     assert(new_called == 1);
     assert(f2.target<A>());

test/utilities/function.objects/func.wrap/func.wrap.func/func.wrap.func.con/copy_assign.pass.cpp

@@ -111,7 +111,7 @@ int main()
     assert(f.target<A>());
     assert(f.target<int(*)(int)>() == 0);
     std::function<int(int)> f2;
-    f2 = _STD::move(f);
+    f2 = std::move(f);
     assert(A::count == 1);
     assert(new_called == 1);
     assert(f2.target<A>());

test/utilities/type.index/type.index.members/lt.pass.cpp

@@ -28,8 +28,18 @@ int main()
     assert( (t1 <= t2));
     assert(!(t1 >  t2));
     assert( (t1 >= t2));
-    assert(!(t1 <  t3));
-    assert(!(t1 <= t3));
-    assert( (t1 >  t3));
-    assert( (t1 >= t3));
+    if (t1 < t3)
+    {
+        assert( (t1 <  t3));
+        assert( (t1 <= t3));
+        assert(!(t1 >  t3));
+        assert(!(t1 >= t3));
+    }
+    else
+    {
+        assert(!(t1 <  t3));
+        assert(!(t1 <= t3));
+        assert( (t1 >  t3));
+        assert( (t1 >= t3));
+    }
 }

test/utilities/utility/pairs/pair.piecewise/piecewise_construct.pass.cpp

@@ -15,8 +15,41 @@
 // constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
 
 #include <utility>
+#include <tuple>
+#include <cassert>
+
+class A
+{
+    int i_;
+    char c_;
+public:
+    A(int i, char c) : i_(i), c_(c) {}
+    int get_i() const {return i_;}
+    char get_c() const {return c_;}
+};
+
+class B
+{
+    double d_;
+    unsigned u1_;
+    unsigned u2_;
+public:
+    B(double d, unsigned u1, unsigned u2) : d_(d), u1_(u1), u2_(u2) {}
+    double get_d() const {return d_;}
+    unsigned get_u1() const {return u1_;}
+    unsigned get_u2() const {return u2_;}
+};
 
 int main()
 {
-    std::piecewise_construct_t p = std::piecewise_construct;
+#ifndef _LIBCPP_HAS_NO_VARIADICS
+    std::pair<A, B> p(std::piecewise_construct,
+                      std::make_tuple(4, 'a'),
+                      std::make_tuple(3.5, 6u, 2u));
+    assert(p.first.get_i() == 4);
+    assert(p.first.get_c() == 'a');
+    assert(p.second.get_d() == 3.5);
+    assert(p.second.get_u1() == 6u);
+    assert(p.second.get_u2() == 2u);
+#endif
 }

www/index.html

@@ -177,6 +177,12 @@
   <ul>
   <li><code>cd libcxx/test</code></li>
   <li><code>./testit</code></li>
+     <ul>
+       <li><p>On Mac OS 10.6 add "-U__STRICT_ANSI__" to the command line with:</p>
+           <blockquote><pre>
+export OPTIONS="-std=c++0x -stdlib=libc++ -U__STRICT_ANSI__"
+           </pre></blockqutoe></li>
+     </ul>
   </ul>
 
   <p>Send discussions to the