more Apple build system tweaks

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-23.1@132818 91177308-0d34-0410-b5e6-96231b3b80d8
libcpp-23.1
2011-06-09 23:30:26 +00:00 · 2011-06-09 22:18:19 +00:00 · 2011-05-24 20:29:16 +00:00
437 changed files with 6349 additions and 16358 deletions
--- a/CREDITS.TXT
+++ b/CREDITS.TXT
@@ -16,19 +16,3 @@ N: Marshall Clow
 E: marshall@idio.com
 E: mclow@qualcomm.com
 D: Minor patches and bug fixes.
-
-N: Bjorn Reese
-E: breese@users.sourceforge.net
-D: Initial regex prototype
-
-N: David Chisnall
-E: theraven at theravensnest dot org
-D: FreeBSD port and libcxxrt support.
-
-N: Ruben Van Boxem
-E: vanboxem dot ruben at gmail dot com
-D: Initial Windows patches.
-
-N: Arvid Picciani
-E: aep at exys dot org
-D: Minor patches and musl port.
--- a/38
+++ b/38
@@ -15,9 +15,6 @@ else
 	INSTALL_PREFIX="$(SDKROOT)"
 endif

-help::
-	echo Use make install DSTROOT=<destination>
-
 installsrc:: $(SRCROOT)

 	ditto $(SRCDIRS)/include $(SRCROOT)/include
@@ -29,34 +26,13 @@ clean::

 installhdrs::

-	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/ext
-	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/ext
-	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/ext
-	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/ext
-	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/
-	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/
-	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/
-	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/
-	chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++
-	chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++
-	chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++
-	chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/*
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/*
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/*
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/*
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/ext
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/ext
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/ext
-	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/ext
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/lib/c++/v1/ext/*
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/clang-ide/lib/c++/v1/ext/*
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/usr/lib/c++/v1/ext/*
-	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/Developer/Platforms/iPhoneOS.platform/usr/lib/c++/v1/ext/*
+	mkdir -p $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext
+	rsync -r --exclude=".*" $(SRCDIRS)/include/* $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/
+	chown -R root:wheel $(DSTROOT)/$(INSTALL_PREFIX)/usr/include
+	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1
+	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/*
+	chmod 755 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext
+	chmod 644 $(DSTROOT)/$(INSTALL_PREFIX)/usr/include/c++/v1/ext/*

 install:: installhdrs $(DESTDIR)

--- a/include/__bit_reference
+++ b/include/__bit_reference
@@ -21,13 +21,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 template <class _C, bool _IsConst> class __bit_iterator;
 template <class _C> class __bit_const_reference;

-template <class _Tp>
-struct __has_storage_type
-{
-    static const bool value = false;
-};
-
-template <class _C, bool = __has_storage_type<_C>::value>
+template <class _C>
 class __bit_reference
 {
    typedef typename _C::__storage_type    __storage_type;
@@ -44,13 +38,11 @@ class __bit_reference
    friend class __bit_const_reference<_C>;
    friend class __bit_iterator<_C, false>;
 public:
-    _LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
-        {return static_cast<bool>(*__seg_ & __mask_);}
-    _LIBCPP_INLINE_VISIBILITY bool operator ~() const _NOEXCEPT
-        {return !static_cast<bool>(*this);}
+    _LIBCPP_INLINE_VISIBILITY operator bool() const {return static_cast<bool>(*__seg_ & __mask_);}
+    _LIBCPP_INLINE_VISIBILITY bool operator ~() const {return !static_cast<bool>(*this);}

    _LIBCPP_INLINE_VISIBILITY
-    __bit_reference& operator=(bool __x) _NOEXCEPT
+    __bit_reference& operator=(bool __x)
    {
        if (__x)
            *__seg_ |= __mask_;
@@ -60,27 +52,20 @@ public:
    }

    _LIBCPP_INLINE_VISIBILITY
-    __bit_reference& operator=(const __bit_reference& __x) _NOEXCEPT
-        {return operator=(static_cast<bool>(__x));}
+    __bit_reference& operator=(const __bit_reference& __x) {return operator=(static_cast<bool>(__x));}

-    _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {*__seg_ ^= __mask_;}
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, false> operator&() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY void flip() {*__seg_ ^= __mask_;}
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, false> operator&() const
        {return __bit_iterator<_C, false>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
 private:
    _LIBCPP_INLINE_VISIBILITY
-    __bit_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
-        : __seg_(__s), __mask_(__m) {}
-};
-
-template <class _C>
-class __bit_reference<_C, false>
-{
+    __bit_reference(__storage_pointer __s, __storage_type __m) : __seg_(__s), __mask_(__m) {}
 };

 template <class _C, class _D>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-swap(__bit_reference<_C> __x, __bit_reference<_D> __y) _NOEXCEPT
+swap(__bit_reference<_C> __x, __bit_reference<_D> __y)
 {
    bool __t = __x;
    __x = __y;
@@ -90,7 +75,7 @@ swap(__bit_reference<_C> __x, __bit_reference<_D> __y) _NOEXCEPT
 template <class _C>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-swap(__bit_reference<_C> __x, bool& __y) _NOEXCEPT
+swap(__bit_reference<_C> __x, bool& __y)
 {
    bool __t = __x;
    __x = __y;
@@ -100,7 +85,7 @@ swap(__bit_reference<_C> __x, bool& __y) _NOEXCEPT
 template <class _C>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-swap(bool& __x, __bit_reference<_C> __y) _NOEXCEPT
+swap(bool& __x, __bit_reference<_C> __y)
 {
    bool __t = __x;
    __x = __y;
@@ -124,18 +109,16 @@ class __bit_const_reference
    friend class __bit_iterator<_C, true>;
 public:
    _LIBCPP_INLINE_VISIBILITY
-    __bit_const_reference(const __bit_reference<_C>& __x) _NOEXCEPT
+    __bit_const_reference(const __bit_reference<_C>& __x)
        : __seg_(__x.__seg_), __mask_(__x.__mask_) {}

-    _LIBCPP_INLINE_VISIBILITY operator bool() const _NOEXCEPT
-        {return static_cast<bool>(*__seg_ & __mask_);}
+    _LIBCPP_INLINE_VISIBILITY operator bool() const {return static_cast<bool>(*__seg_ & __mask_);}

-    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, true> operator&() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator<_C, true> operator&() const
        {return __bit_iterator<_C, true>(__seg_, static_cast<unsigned>(__ctz(__mask_)));}
 private:
    _LIBCPP_INLINE_VISIBILITY
-    __bit_const_reference(__storage_pointer __s, __storage_type __m) _NOEXCEPT
-        : __seg_(__s), __mask_(__m) {}
+    __bit_const_reference(__storage_pointer __s, __storage_type __m) : __seg_(__s), __mask_(__m) {}

    __bit_const_reference& operator=(const __bit_const_reference& __x);
 };
@@ -153,25 +136,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 = _VSTD::min(__clz_f, __n);
+        __storage_type __dn = _STD::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>(_VSTD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_STD::__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>(_VSTD::__ctz(*__first.__seg_)));
+            return _It(__first.__seg_, static_cast<unsigned>(_STD::__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>(_VSTD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
    }
    return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
@@ -187,11 +170,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 = _VSTD::min(__clz_f, __n);
+        __storage_type __dn = _STD::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>(_VSTD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
        __n -= __dn;
        ++__first.__seg_;
    }
@@ -200,7 +183,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>(_VSTD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
    }
    // do last partial word
    if (__n > 0)
@@ -208,7 +191,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>(_VSTD::__ctz(__b)));
+            return _It(__first.__seg_, static_cast<unsigned>(_STD::__ctz(__b)));
    }
    return _It(__first.__seg_, static_cast<unsigned>(__n));
 }
@@ -238,20 +221,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 = _VSTD::min(__clz_f, __n);
+        __storage_type __dn = _STD::min(__clz_f, __n);
        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __r = _VSTD::__pop_count(*__first.__seg_ & __m);
+        __r = _STD::__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 += _VSTD::__pop_count(*__first.__seg_);
+        __r += _STD::__pop_count(*__first.__seg_);
    // do last partial word
    if (__n > 0)
    {
        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __r += _VSTD::__pop_count(*__first.__seg_ & __m);
+        __r += _STD::__pop_count(*__first.__seg_ & __m);
    }
    return __r;
 }
@@ -269,20 +252,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 = _VSTD::min(__clz_f, __n);
+        __storage_type __dn = _STD::min(__clz_f, __n);
        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
-        __r = _VSTD::__pop_count(~(*__first.__seg_ & __m));
+        __r = _STD::__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 += _VSTD::__pop_count(~*__first.__seg_);
+        __r += _STD::__pop_count(~*__first.__seg_);
    // do last partial word
    if (__n > 0)
    {
        __storage_type __m = ~__storage_type(0) >> (__bits_per_word - __n);
-        __r += _VSTD::__pop_count(~(*__first.__seg_ & __m));
+        __r += _STD::__pop_count(~(*__first.__seg_ & __m));
    }
    return __r;
 }
@@ -310,7 +293,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 = _VSTD::min(__clz_f, __n);
+        __storage_type __dn = _STD::min(__clz_f, __n);
        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
        *__first.__seg_ &= ~__m;
        __n -= __dn;
@@ -318,7 +301,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;
-    _VSTD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
+    _STD::memset(__first.__seg_, 0, __nw * sizeof(__storage_type));
    __n -= __nw * __bits_per_word;
    // do last partial word
    if (__n > 0)
@@ -340,7 +323,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 = _VSTD::min(__clz_f, __n);
+        __storage_type __dn = _STD::min(__clz_f, __n);
        __storage_type __m = (~__storage_type(0) << __first.__ctz_) & (~__storage_type(0) >> (__clz_f - __dn));
        *__first.__seg_ |= __m;
        __n -= __dn;
@@ -348,7 +331,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;
-    _VSTD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
+    _STD::memset(__first.__seg_, -1, __nw * sizeof(__storage_type));
    __n -= __nw * __bits_per_word;
    // do last partial word
    if (__n > 0)
@@ -380,7 +363,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 fill(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __last, bool __value)
 {
-    _VSTD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
+    _STD::fill_n(__first, static_cast<typename _C::size_type>(__last - __first), __value);
 }

 // copy
@@ -401,7 +384,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 = _VSTD::min(static_cast<difference_type>(__clz), __n);
+            difference_type __dn = _STD::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;
@@ -415,7 +398,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;
-        _VSTD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
+        _STD::memmove(__result.__seg_, __first.__seg_, __nw * sizeof(__storage_type));
        __n -= __nw * __bits_per_word;
        __result.__seg_ += __nw;
        // do last word
@@ -448,12 +431,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 = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            difference_type __dn = _STD::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 = _VSTD::min<__storage_type>(__dn, __clz_r);
+            __storage_type __ddn = _STD::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_)
@@ -491,7 +474,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 = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
+            __storage_type __dn = _STD::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_;
@@ -537,7 +520,7 @@ __copy_backward_aligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_C,
        // do first word
        if (__last.__ctz_ != 0)
        {
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            difference_type __dn = _STD::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);
@@ -554,7 +537,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;
-        _VSTD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
+        _STD::memmove(__result.__seg_, __last.__seg_, __nw * sizeof(__storage_type));
        __n -= __nw * __bits_per_word;
        // do last word
        if (__n > 0)
@@ -584,13 +567,13 @@ __copy_backward_unaligned(__bit_iterator<_C, _IsConst> __first, __bit_iterator<_
        // do first word
        if (__last.__ctz_ != 0)
        {
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__last.__ctz_), __n);
+            difference_type __dn = _STD::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 = _VSTD::min(__dn, static_cast<difference_type>(__result.__ctz_));
+            __storage_type __ddn = _STD::min(__dn, static_cast<difference_type>(__result.__ctz_));
            if (__ddn > 0)
            {
                __m = (~__storage_type(0) << (__result.__ctz_ - __ddn)) & (~__storage_type(0) >> __clz_r);
@@ -634,7 +617,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 = _VSTD::min(__n, static_cast<difference_type>(__result.__ctz_));
+            __storage_type __dn = _STD::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_);
@@ -672,7 +655,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 _VSTD::copy(__first, __last, __result);
+    return _STD::copy(__first, __last, __result);
 }

 // move_backward
@@ -682,17 +665,17 @@ 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 _VSTD::copy(__first, __last, __result);
+    return _STD::copy(__first, __last, __result);
 }

 // swap_ranges

-template <class __C1, class __C2>
-__bit_iterator<__C2, false>
-__swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
-                      __bit_iterator<__C2, false> __result)
+template <class _C1, class _C2>
+__bit_iterator<_C2, false>
+__swap_ranges_aligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, false> __last,
+                      __bit_iterator<_C2, false> __result)
 {
-    typedef __bit_iterator<__C1, false> _I1;
+    typedef __bit_iterator<_C1, false> _I1;
    typedef  typename _I1::difference_type difference_type;
    typedef typename _I1::__storage_type __storage_type;
    static const unsigned __bits_per_word = _I1::__bits_per_word;
@@ -703,7 +686,7 @@ __swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1,
        if (__first.__ctz_ != 0)
        {
            unsigned __clz = __bits_per_word - __first.__ctz_;
-            difference_type __dn = _VSTD::min(static_cast<difference_type>(__clz), __n);
+            difference_type __dn = _STD::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;
@@ -737,12 +720,12 @@ __swap_ranges_aligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1,
    return __result;
 }

-template <class __C1, class __C2>
-__bit_iterator<__C2, false>
-__swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1, false> __last,
-                        __bit_iterator<__C2, false> __result)
+template <class _C1, class _C2>
+__bit_iterator<_C2, false>
+__swap_ranges_unaligned(__bit_iterator<_C1, false> __first, __bit_iterator<_C1, false> __last,
+                        __bit_iterator<_C2, false> __result)
 {
-    typedef __bit_iterator<__C1, false> _I1;
+    typedef __bit_iterator<_C1, false> _I1;
    typedef  typename _I1::difference_type difference_type;
    typedef typename _I1::__storage_type __storage_type;
    static const unsigned __bits_per_word = _I1::__bits_per_word;
@@ -753,13 +736,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 = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            difference_type __dn = _STD::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 = _VSTD::min<__storage_type>(__dn, __clz_r);
+            __storage_type __ddn = _STD::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;
@@ -814,7 +797,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 = _VSTD::min<__storage_type>(__n, __clz_r);
+            __storage_type __dn = _STD::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;
@@ -837,11 +820,11 @@ __swap_ranges_unaligned(__bit_iterator<__C1, false> __first, __bit_iterator<__C1
    return __result;
 }

-template <class __C1, class __C2>
+template <class _C1, class _C2>
 inline _LIBCPP_INLINE_VISIBILITY
-__bit_iterator<__C2, false>
-swap_ranges(__bit_iterator<__C1, false> __first1, __bit_iterator<__C1, false> __last1,
-            __bit_iterator<__C2, false> __first2)
+__bit_iterator<_C2, false>
+swap_ranges(__bit_iterator<_C1, false> __first1, __bit_iterator<_C1, false> __last1,
+            __bit_iterator<_C2, false> __first2)
 {
    if (__first1.__ctz_ == __first2.__ctz_)
        return __swap_ranges_aligned(__first1, __last1, __first2);
@@ -888,13 +871,13 @@ rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __
            if (__d1 <= __bit_array<_C>::capacity())
            {
                __bit_array<_C> __b(__d1);
-                _VSTD::copy(__first, __middle, __b.begin());
-                _VSTD::copy(__b.begin(), __b.end(), _VSTD::copy(__middle, __last, __first));
+                _STD::copy(__first, __middle, __b.begin());
+                _STD::copy(__b.begin(), __b.end(), _STD::copy(__middle, __last, __first));
                break;
            }
            else
            {
-                __bit_iterator<_C, false> __mp = _VSTD::swap_ranges(__first, __middle, __middle);
+                __bit_iterator<_C, false> __mp = _STD::swap_ranges(__first, __middle, __middle);
                __first = __middle;
                __middle = __mp;
                __d2 -= __d1;
@@ -905,14 +888,14 @@ rotate(__bit_iterator<_C, false> __first, __bit_iterator<_C, false> __middle, __
            if (__d2 <= __bit_array<_C>::capacity())
            {
                __bit_array<_C> __b(__d2);
-                _VSTD::copy(__middle, __last, __b.begin());
-                _VSTD::copy_backward(__b.begin(), __b.end(), _VSTD::copy_backward(__first, __middle, __last));
+                _STD::copy(__middle, __last, __b.begin());
+                _STD::copy_backward(__b.begin(), __b.end(), _STD::copy_backward(__first, __middle, __last));
                break;
            }
            else
            {
                __bit_iterator<_C, false> __mp = __first + __d2;
-                _VSTD::swap_ranges(__first, __mp, __middle);
+                _STD::swap_ranges(__first, __mp, __middle);
                __first = __mp;
                __d1 -= __d2;
            }
@@ -939,12 +922,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 = _VSTD::min(static_cast<difference_type>(__clz_f), __n);
+            difference_type __dn = _STD::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 = _VSTD::min<__storage_type>(__dn, __clz_r);
+            __storage_type __ddn = _STD::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_)))
@@ -983,7 +966,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 = _VSTD::min(__n, static_cast<difference_type>(__clz_r));
+            __storage_type __dn = _STD::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;
@@ -1017,7 +1000,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 = _VSTD::min(static_cast<difference_type>(__clz), __n);
+            difference_type __dn = _STD::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))
@@ -1074,14 +1057,12 @@ private:
    unsigned          __ctz_;

 public:
-    _LIBCPP_INLINE_VISIBILITY __bit_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator() {}

-    _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(const __bit_iterator<_C, false>& __it) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY __bit_iterator(const __bit_iterator<_C, false>& __it)
        : __seg_(__it.__seg_), __ctz_(__it.__ctz_) {}

-    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
-        {return reference(__seg_, __storage_type(1) << __ctz_);}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return reference(__seg_, __storage_type(1) << __ctz_);}

    _LIBCPP_INLINE_VISIBILITY __bit_iterator& operator++()
    {
@@ -1181,8 +1162,7 @@ public:

 private:
    _LIBCPP_INLINE_VISIBILITY
-    __bit_iterator(__storage_pointer __s, unsigned __ctz) _NOEXCEPT
-        : __seg_(__s), __ctz_(__ctz) {}
+    __bit_iterator(__storage_pointer __s, unsigned __ctz) : __seg_(__s), __ctz_(__ctz) {}

 #if defined(__clang__)
    friend typename _C::__self;
@@ -1213,15 +1193,15 @@ private:
    template <class _D, bool _IC> friend __bit_iterator<_D, false> copy_backward(__bit_iterator<_D, _IC> __first,
                                                                                 __bit_iterator<_D, _IC> __last,
                                                                                 __bit_iterator<_D, false> __result);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_aligned(__bit_iterator<__C1, false>,
-                                                                                           __bit_iterator<__C1, false>,
-                                                                                           __bit_iterator<__C2, false>);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> __swap_ranges_unaligned(__bit_iterator<__C1, false>,
-                                                                                             __bit_iterator<__C1, false>,
-                                                                                             __bit_iterator<__C2, false>);
-    template <class __C1, class __C2>friend __bit_iterator<__C2, false> swap_ranges(__bit_iterator<__C1, false>,
-                                                                                 __bit_iterator<__C1, false>,
-                                                                                 __bit_iterator<__C2, false>);
+    template <class _C1, class _C2>friend __bit_iterator<_C2, false> __swap_ranges_aligned(__bit_iterator<_C1, false>,
+                                                                                           __bit_iterator<_C1, false>,
+                                                                                           __bit_iterator<_C2, false>);
+    template <class _C1, class _C2>friend __bit_iterator<_C2, false> __swap_ranges_unaligned(__bit_iterator<_C1, false>,
+                                                                                             __bit_iterator<_C1, false>,
+                                                                                             __bit_iterator<_C2, false>);
+    template <class _C1, class _C2>friend __bit_iterator<_C2, false> swap_ranges(__bit_iterator<_C1, false>,
+                                                                                 __bit_iterator<_C1, false>,
+                                                                                 __bit_iterator<_C2, false>);
    template <class _D> friend __bit_iterator<_D, false> rotate(__bit_iterator<_D, false>,
                                                                __bit_iterator<_D, false>,
                                                                __bit_iterator<_D, false>);
--- a/include/__config
+++ b/include/__config
@@ -13,7 +13,7 @@

 #pragma GCC system_header

-#define _LIBCPP_VERSION 1001
+#define _LIBCPP_VERSION 1000

 #define _LIBCPP_ABI_VERSION 1

@@ -50,10 +50,6 @@
 #ifdef _WIN32
 #  define _LIBCPP_LITTLE_ENDIAN 1
 #  define _LIBCPP_BIG_ENDIAN    0
-// Compiler intrinsics (GCC or MSVC)
-#  if (defined(_MSC_VER) && _MSC_VER >= 1400) || (__GNUC__ >= 4 && __GNUC_MINOR__ > 3)
-#    define _LIBCP_HAS_IS_BASE_OF
-#  endif
 #endif  // _WIN32

 #if !defined(_LIBCPP_LITTLE_ENDIAN) || !defined(_LIBCPP_BIG_ENDIAN)
@@ -95,9 +91,9 @@

 #if defined(__clang__)

-#if !__has_feature(cxx_alias_templates)
+//#if !__has_feature(cxx_alias_templates)
 #define _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-#endif
+//#endif

 #ifndef __GXX_EXPERIMENTAL_CXX0X__
 #ifdef __linux__
@@ -120,10 +116,8 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_DECLTYPE
 #endif

-#if __has_feature(cxx_attributes)
-#  define _ATTRIBUTE(x) [[x]]
-#else
-#  define _ATTRIBUTE(x) __attribute__ ((x))
+#if !(__has_feature(cxx_attributes))
+#define _LIBCPP_HAS_NO_ATTRIBUTES
 #endif

 #define _LIBCPP_HAS_NO_DEFAULTED_FUNCTIONS
@@ -150,9 +144,6 @@ typedef __char32_t char32_t;

 #if !(__has_feature(cxx_auto_type))
 #define _LIBCPP_HAS_NO_AUTO_TYPE
-#endif
-
-#if !(__has_feature(cxx_access_control_sfinae)) || !__has_feature(cxx_trailing_return)
 #define _LIBCPP_HAS_NO_ADVANCED_SFINAE
 #endif

@@ -164,27 +155,10 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_TRAILING_RETURN
 #endif

-#if !(__has_feature(cxx_generalized_initializers))
-#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-#endif
-
-#if __has_feature(is_base_of)
-#  define _LIBCP_HAS_IS_BASE_OF
-#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 _VSTD std::_LIBCPP_NAMESPACE
+#define _STD std::_LIBCPP_NAMESPACE

 namespace std {
  inline namespace _LIBCPP_NAMESPACE {
@@ -203,16 +177,10 @@ namespace std {
 #  define _NOEXCEPT_(x)
 #endif

-#if __has_feature(underlying_type)
-#  define _LIBCXX_UNDERLYING_TYPE(T) __underlying_type(T)
-#endif
-
 // end defined(__clang__)

 #elif defined(__GNUC__)

-#define _ATTRIBUTE(x) __attribute__((x))
-
 #if !__EXCEPTIONS
 #define _LIBCPP_NO_EXCEPTIONS
 #endif
@@ -256,7 +224,6 @@ namespace std {
 #define _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_VARIADICS
-#define _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
 #endif  // !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 4)

 #if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 6)
@@ -267,7 +234,7 @@ namespace std {

 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std { namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
-#define _VSTD std::_LIBCPP_NAMESPACE
+#define _STD std::_LIBCPP_NAMESPACE

 namespace std {
 namespace _LIBCPP_NAMESPACE {
@@ -305,32 +272,4 @@ template <unsigned> struct __static_assert_check {};
 #define __has_feature(__x) 0
 #endif

-#if __APPLE__ || __FreeBSD__ || _WIN32
-#define _LIBCPP_LOCALE__L_EXTENSIONS 1
-#endif
-
-#if __APPLE__ || __FreeBSD__
-#define _LIBCPP_HAS_DEFAULTRUNELOCALE
-#endif
-
-#if __APPLE__ || __FreeBSD__
-#define _LIBCPP_WCTYPE_IS_MASK
-#endif
-
-#ifdef _LIBCPP_DEBUG2
-#   if _LIBCPP_DEBUG2 == 0
-#       define _LIBCPP_DEBUG_LEVEL 1
-#   elif _LIBCPP_DEBUG2 == 1
-#       define _LIBCPP_DEBUG_LEVEL 2
-#   else
-#       error Supported values for _LIBCPP_DEBUG2 are 0 and 1
-#   endif
-#endif
-
-#ifdef _LIBCPP_DEBUG2
-#   include <__debug>
-#else
-#   define _LIBCPP_ASSERT(x, m) ((void)0)
-#endif
-
 #endif  // _LIBCPP_CONFIG
--- a/include/__debug
+++ b/include/__debug
@@ -1,191 +0,0 @@
-// -*- C++ -*-
-//===--------------------------- __debug ----------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_DEBUG_H
-#define _LIBCPP_DEBUG_H
-
-#if _LIBCPP_DEBUG_LEVEL >= 1
-
-#   include <cstdlib>
-#   include <cstdio>
-#   include <cstddef>
-#   define _LIBCPP_ASSERT(x, m) ((x) ? (void)0 : (_VSTD::printf("%s\n", m), _VSTD::abort()))
-
-#endif
-
-#if _LIBCPP_DEBUG_LEVEL >= 2
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-struct _LIBCPP_VISIBLE __c_node;
-
-struct _LIBCPP_VISIBLE __i_node
-{
-    void* __i_;
-    __i_node* __next_;
-    __c_node* __c_;
-
-    __i_node(const __i_node&) = delete;
-    __i_node& operator=(const __i_node&) = delete;
-    _LIBCPP_INLINE_VISIBILITY
-    __i_node(void* __i, __i_node* __next, __c_node* __c)
-        : __i_(__i), __next_(__next), __c_(__c) {}
-    ~__i_node();
-};
-
-struct _LIBCPP_VISIBLE __c_node
-{
-    void* __c_;
-    __c_node* __next_;
-    __i_node** beg_;
-    __i_node** end_;
-    __i_node** cap_;
-
-    __c_node(const __c_node&) = delete;
-    __c_node& operator=(const __c_node&) = delete;
-    _LIBCPP_INLINE_VISIBILITY
-    __c_node(void* __c, __c_node* __next)
-        : __c_(__c), __next_(__next), beg_(nullptr), end_(nullptr), cap_(nullptr) {}
-    virtual ~__c_node();
-
-    virtual bool __dereferenceable(const void*) const = 0;
-    virtual bool __decrementable(const void*) const = 0;
-    virtual bool __addable(const void*, ptrdiff_t) const = 0;
-    virtual bool __subscriptable(const void*, ptrdiff_t) const = 0;
-
-    void __add(__i_node* __i);
-    _LIBCPP_HIDDEN void __remove(__i_node* __i);
-};
-
-template <class _Cont>
-struct _C_node
-    : public __c_node
-{
-    _C_node(void* __c, __c_node* __n)
-        : __c_node(__c, __n) {}
-
-    virtual bool __dereferenceable(const void*) const;
-    virtual bool __decrementable(const void*) const;
-    virtual bool __addable(const void*, ptrdiff_t) const;
-    virtual bool __subscriptable(const void*, ptrdiff_t) const;
-};
-
-template <class _Cont>
-bool
-_C_node<_Cont>::__dereferenceable(const void* __i) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* _C = static_cast<_Cont*>(__c_);
-    return _C->__dereferenceable(__j);
-}
-
-template <class _Cont>
-bool
-_C_node<_Cont>::__decrementable(const void* __i) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* _C = static_cast<_Cont*>(__c_);
-    return _C->__decrementable(__j);
-}
-
-template <class _Cont>
-bool
-_C_node<_Cont>::__addable(const void* __i, ptrdiff_t __n) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* _C = static_cast<_Cont*>(__c_);
-    return _C->__addable(__j, __n);
-}
-
-template <class _Cont>
-bool
-_C_node<_Cont>::__subscriptable(const void* __i, ptrdiff_t __n) const
-{
-    typedef typename _Cont::const_iterator iterator;
-    const iterator* __j = static_cast<const iterator*>(__i);
-    _Cont* _C = static_cast<_Cont*>(__c_);
-    return _C->__subscriptable(__j, __n);
-}
-
-class _LIBCPP_VISIBLE __libcpp_db
-{
-    __c_node** __cbeg_;
-    __c_node** __cend_;
-    size_t   __csz_;
-    __i_node** __ibeg_;
-    __i_node** __iend_;
-    size_t   __isz_;
-
-    __libcpp_db();
-public:
-    __libcpp_db(const __libcpp_db&) = delete;
-    __libcpp_db& operator=(const __libcpp_db&) = delete;
-    ~__libcpp_db();
-
-    class __db_c_iterator;
-    class __db_c_const_iterator;
-    class __db_i_iterator;
-    class __db_i_const_iterator;
-
-    __db_c_const_iterator __c_end() const;
-    __db_i_const_iterator __i_end() const;
-
-    template <class _Cont>
-    _LIBCPP_INLINE_VISIBILITY
-    void __insert_c(_Cont* __c)
-    {
-        __c_node* __n = __insert_c(static_cast<void*>(__c));
-        ::new(__n) _C_node<_Cont>(__n->__c_, __n->__next_);
-    }
-
-    void __insert_i(void* __i);
-    __c_node* __insert_c(void* __c);
-    void __erase_c(void* __c);
-
-    void __insert_ic(void* __i, const void* __c);
-    void __iterator_copy(void* __i, const void* __i0);
-    void __erase_i(void* __i);
-
-    void* __find_c_from_i(void* __i) const;
-    void __invalidate_all(void* __c);
-    __c_node* __find_c_and_lock(void* __c) const;
-    __c_node* __find_c(void* __c) const;
-    void unlock() const;
-
-    void swap(void* __c1, void* __c2);
-
-
-    bool __dereferenceable(const void* __i) const;
-    bool __decrementable(const void* __i) const;
-    bool __addable(const void* __i, ptrdiff_t __n) const;
-    bool __subscriptable(const void* __i, ptrdiff_t __n) const;
-    bool __comparable(const void* __i, const void* __j) const;
-private:
-    _LIBCPP_HIDDEN
-    __i_node* __insert_iterator(void* __i);
-    _LIBCPP_HIDDEN
-    __i_node* __find_iterator(const void* __i) const;
-
-    friend _LIBCPP_VISIBLE __libcpp_db* __get_db();
-};
-
-_LIBCPP_VISIBLE __libcpp_db* __get_db();
-_LIBCPP_VISIBLE const __libcpp_db* __get_const_db();
-
-
-_LIBCPP_END_NAMESPACE_STD
-
-#endif
-
-#endif  // _LIBCPP_DEBUG_H
-
--- a/include/__functional_03
+++ b/include/__functional_03
@@ -314,8 +314,8 @@ class __func<_F, _Alloc, _R()>
 {
    __compressed_pair<_F, _Alloc> __f_;
 public:
-    explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
-    explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
+    explicit __func(_F __f) : __f_(_STD::move(__f)) {}
+    explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::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_(_VSTD::move(__f)) {}
+    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
-        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
+        : __f_(_STD::move(__f), _STD::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_(_VSTD::move(__f)) {}
+    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
-        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
+        : __f_(_STD::move(__f), _STD::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_(_VSTD::move(__f)) {}
+    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f) : __f_(_STD::move(__f)) {}
    _LIBCPP_INLINE_VISIBILITY explicit __func(_F __f, _Alloc __a)
-        : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
+        : __f_(_STD::move(__f), _STD::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(_VSTD::move(__f)).swap(*this);
+    function(_STD::move(__f)).swap(*this);
    return *this;
 }

@@ -878,7 +878,7 @@ function<_R()>::swap(function& __f)
        __f_ = (__base*)&__buf_;
    }
    else
-        _VSTD::swap(__f_, __f.__f_);
+        _STD::swap(__f_, __f.__f_);
 }

 template<class _R>
@@ -1133,7 +1133,7 @@ typename enable_if
 >::type
 function<_R(_A0)>::operator=(_F __f)
 {
-    function(_VSTD::move(__f)).swap(*this);
+    function(_STD::move(__f)).swap(*this);
    return *this;
 }

@@ -1180,7 +1180,7 @@ function<_R(_A0)>::swap(function& __f)
        __f_ = (__base*)&__buf_;
    }
    else
-        _VSTD::swap(__f_, __f.__f_);
+        _STD::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(_VSTD::move(__f)).swap(*this);
+    function(_STD::move(__f)).swap(*this);
    return *this;
 }

@@ -1482,7 +1482,7 @@ function<_R(_A0, _A1)>::swap(function& __f)
        __f_ = (__base*)&__buf_;
    }
    else
-        _VSTD::swap(__f_, __f.__f_);
+        _STD::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(_VSTD::move(__f)).swap(*this);
+    function(_STD::move(__f)).swap(*this);
    return *this;
 }

@@ -1784,7 +1784,7 @@ function<_R(_A0, _A1, _A2)>::swap(function& __f)
        __f_ = (__base*)&__buf_;
    }
    else
-        _VSTD::swap(__f_, __f.__f_);
+        _STD::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(_VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj))...);
+    __ti(_STD::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 _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+//    return _STD::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_(_VSTD::forward<_G>(__f)),
-          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
+        : __f_(_STD::forward<_G>(__f)),
+          __bound_args_(_STD::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(_VSTD::forward<_G>(__f),
-               _VSTD::forward<_BA>(__bound_args)...) {}
+        : base(_STD::forward<_G>(__f),
+               _STD::forward<_BA>(__bound_args)...) {}

    template <class ..._Args>
        result_type
        operator()(_Args&& ...__args)
        {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            return base::operator()(_STD::forward<_Args>(__args)...);
        }

    template <class ..._Args>
        result_type
        operator()(_Args&& ...__args) const
        {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            return base::operator()(_STD::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(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
+    return type(_STD::forward<_F>(__f), _STD::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(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
+    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
 }
 */

--- a/include/__functional_base
+++ b/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((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...))
+    -> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...))
 {
-    return (_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...);
+    return (_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...);
 }

 template <class _F, class _A0, class ..._Args>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...))
+    -> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...))
 {
-    return ((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...);
+    return ((*_STD::forward<_A0>(__a0)).*__f)(_STD::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(_VSTD::forward<_A0>(__a0).*__f)
+    -> decltype(_STD::forward<_A0>(__a0).*__f)
 {
-    return _VSTD::forward<_A0>(__a0).*__f;
+    return _STD::forward<_A0>(__a0).*__f;
 }

 template <class _F, class _A0>
 inline _LIBCPP_INLINE_VISIBILITY
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype((*_VSTD::forward<_A0>(__a0)).*__f)
+    -> decltype((*_STD::forward<_A0>(__a0)).*__f)
 {
-    return (*_VSTD::forward<_A0>(__a0)).*__f;
+    return (*_STD::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(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...))
+    -> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...))
 {
-    return _VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...);
+    return _STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...);
 }

 template <class _Tp, class ..._Args>
 struct __invoke_return
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_Args>()...)) type;
+    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_Args>()...)) type;
 };

 template <class _Tp>
@@ -350,14 +350,14 @@ private:

 public:
    // construct/copy/destroy
-    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) _NOEXCEPT : __f_(&__f) {}
+    _LIBCPP_INLINE_VISIBILITY reference_wrapper(type& __f) : __f_(&__f) {}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    private: reference_wrapper(type&&); public: // = delete; // do not bind to temps
 #endif

    // access
-    _LIBCPP_INLINE_VISIBILITY operator type&    () const _NOEXCEPT {return *__f_;}
-    _LIBCPP_INLINE_VISIBILITY          type& get() const _NOEXCEPT {return *__f_;}
+    _LIBCPP_INLINE_VISIBILITY operator type&    () const {return *__f_;}
+    _LIBCPP_INLINE_VISIBILITY          type& get() const {return *__f_;}

    // invoke
    template <class... _ArgTypes>
@@ -365,7 +365,7 @@ public:
       typename __invoke_of<type&, _ArgTypes...>::type
          operator() (_ArgTypes&&... __args) const
          {
-              return __invoke(get(), _VSTD::forward<_ArgTypes>(__args)...);
+              return __invoke(get(), _STD::forward<_ArgTypes>(__args)...);
          }
 };

@@ -377,7 +377,7 @@ template <class _Tp> struct __is_reference_wrapper
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>
-ref(_Tp& __t) _NOEXCEPT
+ref(_Tp& __t)
 {
    return reference_wrapper<_Tp>(__t);
 }
@@ -385,7 +385,7 @@ ref(_Tp& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<_Tp>
-ref(reference_wrapper<_Tp> __t) _NOEXCEPT
+ref(reference_wrapper<_Tp> __t)
 {
    return ref(__t.get());
 }
@@ -393,7 +393,7 @@ ref(reference_wrapper<_Tp> __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<const _Tp>
-cref(const _Tp& __t) _NOEXCEPT
+cref(const _Tp& __t)
 {
    return reference_wrapper<const _Tp>(__t);
 }
@@ -401,7 +401,7 @@ cref(const _Tp& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 reference_wrapper<const _Tp>
-cref(reference_wrapper<_Tp> __t) _NOEXCEPT
+cref(reference_wrapper<_Tp> __t)
 {
    return cref(__t.get());
 }
--- a/include/__functional_base_03
+++ b/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(*_VSTD::declval<_T1>()), _R>::type type;
+    typedef typename __apply_cv<decltype(*_STD::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(_VSTD::declval<_F>())) type;
+    typedef decltype(__invoke(_STD::declval<_F>())) type;
 };

 template <class _Tp, class _A0>
 struct __invoke_return0
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>())) type;
+    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::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(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
-                                                    _VSTD::declval<_A1>())) type;
+    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>(),
+                                                    _STD::declval<_A1>())) type;
 };

 template <class _Tp, class _A0, class _A1, class _A2>
 struct __invoke_return2
 {
-    typedef decltype(__invoke(_VSTD::declval<_Tp>(), _VSTD::declval<_A0>(),
-                                                    _VSTD::declval<_A1>(),
-                                                    _VSTD::declval<_A2>())) type;
+    typedef decltype(__invoke(_STD::declval<_Tp>(), _STD::declval<_A0>(),
+                                                    _STD::declval<_A1>(),
+                                                    _STD::declval<_A2>())) type;
 };

 template <class _Tp>
--- a/include/__hash_table
+++ b/include/__hash_table
@@ -23,7 +23,7 @@
 _LIBCPP_BEGIN_NAMESPACE_STD

 _LIBCPP_VISIBLE
-size_t __next_prime(size_t __n);
+size_t __next_prime(size_t);

 template <class _NodePtr>
 struct __hash_node_base
@@ -33,7 +33,7 @@ struct __hash_node_base

    _NodePtr    __next_;

-    _LIBCPP_INLINE_VISIBILITY __hash_node_base() _NOEXCEPT : __next_(nullptr) {}
+    _LIBCPP_INLINE_VISIBILITY __hash_node_base() : __next_(nullptr) {}
 };

 template <class _Tp, class _VoidPtr>
@@ -54,12 +54,11 @@ struct __hash_node
    value_type __value_;
 };

-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, 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 _NodePtr>
 class _LIBCPP_VISIBLE __hash_iterator
@@ -81,12 +80,12 @@ public:
 #endif
                                                         pointer;

-    _LIBCPP_INLINE_VISIBILITY __hash_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __hash_iterator() {}

    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return _VSTD::addressof(__node_->__value_);}
+        pointer operator->() const {return _STD::addressof(__node_->__value_);}

    _LIBCPP_INLINE_VISIBILITY
    __hash_iterator& operator++()
@@ -112,7 +111,7 @@ public:

 private:
    _LIBCPP_INLINE_VISIBILITY
-    __hash_iterator(__node_pointer __node) _NOEXCEPT
+    __hash_iterator(__node_pointer __node)
        : __node_(__node)
        {}

@@ -155,16 +154,16 @@ public:
                                                      __non_const_node_pointer;
    typedef __hash_iterator<__non_const_node_pointer> __non_const_iterator;

-    _LIBCPP_INLINE_VISIBILITY __hash_const_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __hash_const_iterator() {}
    _LIBCPP_INLINE_VISIBILITY 
-    __hash_const_iterator(const __non_const_iterator& __x) _NOEXCEPT
+    __hash_const_iterator(const __non_const_iterator& __x)
        : __node_(__x.__node_)
        {}

    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return _VSTD::addressof(__node_->__value_);}
+        pointer operator->() const {return _STD::addressof(__node_->__value_);}

    _LIBCPP_INLINE_VISIBILITY
    __hash_const_iterator& operator++()
@@ -190,7 +189,7 @@ public:

 private:
    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_iterator(__node_pointer __node) _NOEXCEPT
+    __hash_const_iterator(__node_pointer __node)
        : __node_(__node)
        {}

@@ -200,7 +199,7 @@ private:
    template <class, class, class, class, class> friend class _LIBCPP_VISIBLE unordered_multimap;
 };

-template <class _ConstNodePtr> class _LIBCPP_VISIBLE __hash_const_local_iterator;
+template <class> class _LIBCPP_VISIBLE __hash_const_local_iterator;

 template <class _NodePtr>
 class _LIBCPP_VISIBLE __hash_local_iterator
@@ -225,7 +224,7 @@ public:
 #endif
                                                                pointer;

-    _LIBCPP_INLINE_VISIBILITY __hash_local_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __hash_local_iterator() {}

    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
@@ -259,7 +258,7 @@ public:
 private:
    _LIBCPP_INLINE_VISIBILITY
    __hash_local_iterator(__node_pointer __node, size_t __bucket,
-                          size_t __bucket_count) _NOEXCEPT
+                          size_t __bucket_count)
        : __node_(__node),
          __bucket_(__bucket),
          __bucket_count_(__bucket_count)
@@ -309,9 +308,9 @@ public:
 #endif
                                                       pointer;

-    _LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __hash_const_local_iterator() {}
    _LIBCPP_INLINE_VISIBILITY
-    __hash_const_local_iterator(const __non_const_iterator& __x) _NOEXCEPT
+    __hash_const_local_iterator(const __non_const_iterator& __x)
        : __node_(__x.__node_),
          __bucket_(__x.__bucket_),
          __bucket_count_(__x.__bucket_count_)
@@ -349,7 +348,7 @@ public:
 private:
    _LIBCPP_INLINE_VISIBILITY
    __hash_const_local_iterator(__node_pointer __node, size_t __bucket,
-                                size_t __bucket_count) _NOEXCEPT
+                                size_t __bucket_count)
        : __node_(__node),
          __bucket_(__bucket),
          __bucket_count_(__bucket_count)
@@ -375,44 +374,37 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    __bucket_list_deallocator()
-        _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
        : __data_(0) {}

    _LIBCPP_INLINE_VISIBILITY
    __bucket_list_deallocator(const allocator_type& __a, size_type __size)
-        _NOEXCEPT_(is_nothrow_copy_constructible<allocator_type>::value)
        : __data_(__size, __a) {}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
    __bucket_list_deallocator(__bucket_list_deallocator&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value)
-        : __data_(_VSTD::move(__x.__data_))
+        : __data_(_STD::move(__x.__data_))
    {
        __x.size() = 0;
    }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-    _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __data_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-    size_type  size() const _NOEXCEPT {return __data_.first();}
+    _LIBCPP_INLINE_VISIBILITY size_type& size()       {return __data_.first();}
+    _LIBCPP_INLINE_VISIBILITY size_type  size() const {return __data_.first();}
+
+    _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __data_.second();}
+    _LIBCPP_INLINE_VISIBILITY const allocator_type& __alloc() const {return __data_.second();}

    _LIBCPP_INLINE_VISIBILITY
-    allocator_type& __alloc() _NOEXCEPT {return __data_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const allocator_type& __alloc() const _NOEXCEPT {return __data_.second();}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
+    void operator()(pointer __p)
    {
        __alloc_traits::deallocate(__alloc(), __p, size());
    }
 };

-template <class _Alloc> class __hash_map_node_destructor;
+template <class> class __hash_map_node_destructor;

 template <class _Alloc>
 class __hash_node_destructor
@@ -432,17 +424,16 @@ public:
    bool __value_constructed;

    _LIBCPP_INLINE_VISIBILITY
-    explicit __hash_node_destructor(allocator_type& __na,
-                                    bool __constructed = false) _NOEXCEPT
+    explicit __hash_node_destructor(allocator_type& __na)
        : __na_(__na),
-          __value_constructed(__constructed)
+          __value_constructed(false)
        {}

    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
+    void operator()(pointer __p)
    {
        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -504,32 +495,21 @@ private:
    __compressed_pair<float, key_equal>               __p3_;
    // --- Member data end ---

-    _LIBCPP_INLINE_VISIBILITY
-    size_type& size() _NOEXCEPT {return __p2_.first();}
+    _LIBCPP_INLINE_VISIBILITY size_type& size()       {return __p2_.first();}
 public:
-    _LIBCPP_INLINE_VISIBILITY
-    size_type  size() const _NOEXCEPT {return __p2_.first();}
+    _LIBCPP_INLINE_VISIBILITY size_type  size() const {return __p2_.first();}

-    _LIBCPP_INLINE_VISIBILITY
-    hasher& hash_function() _NOEXCEPT {return __p2_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const hasher& hash_function() const _NOEXCEPT {return __p2_.second();}
+    _LIBCPP_INLINE_VISIBILITY       hasher& hash_function()       {return __p2_.second();}
+    _LIBCPP_INLINE_VISIBILITY const hasher& hash_function() const {return __p2_.second();}

-    _LIBCPP_INLINE_VISIBILITY
-    float& max_load_factor() _NOEXCEPT {return __p3_.first();}
-    _LIBCPP_INLINE_VISIBILITY
-    float  max_load_factor() const _NOEXCEPT {return __p3_.first();}
+    _LIBCPP_INLINE_VISIBILITY float& max_load_factor()       {return __p3_.first();}
+    _LIBCPP_INLINE_VISIBILITY float  max_load_factor() const {return __p3_.first();}

-    _LIBCPP_INLINE_VISIBILITY
-    key_equal& key_eq() _NOEXCEPT {return __p3_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const key_equal& key_eq() const _NOEXCEPT {return __p3_.second();}
+    _LIBCPP_INLINE_VISIBILITY       key_equal& key_eq()       {return __p3_.second();}
+    _LIBCPP_INLINE_VISIBILITY const key_equal& key_eq() const {return __p3_.second();}

-    _LIBCPP_INLINE_VISIBILITY
-    __node_allocator& __node_alloc() _NOEXCEPT {return __p1_.second();}
-    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __p1_.second();}
+    _LIBCPP_INLINE_VISIBILITY __node_allocator&       __node_alloc()       {return __p1_.second();}
+    _LIBCPP_INLINE_VISIBILITY const __node_allocator& __node_alloc() const {return __p1_.second();}

 public:
    typedef __hash_iterator<__node_pointer>                   iterator;
@@ -537,13 +517,7 @@ public:
    typedef __hash_local_iterator<__node_pointer>             local_iterator;
    typedef __hash_const_local_iterator<__node_const_pointer> const_local_iterator;

-    __hash_table()
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__bucket_list>::value &&
-            is_nothrow_default_constructible<__first_node>::value &&
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value);
+    __hash_table();
    __hash_table(const hasher& __hf, const key_equal& __eql);
    __hash_table(const hasher& __hf, const key_equal& __eql,
                 const allocator_type& __a);
@@ -551,25 +525,14 @@ public:
    __hash_table(const __hash_table& __u);
    __hash_table(const __hash_table& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __hash_table(__hash_table&& __u)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__bucket_list>::value &&
-            is_nothrow_move_constructible<__first_node>::value &&
-            is_nothrow_move_constructible<__node_allocator>::value &&
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value);
+    __hash_table(__hash_table&& __u);
    __hash_table(__hash_table&& __u, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    ~__hash_table();

    __hash_table& operator=(const __hash_table& __u);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __hash_table& operator=(__hash_table&& __u)
-        _NOEXCEPT_(
-            __node_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<__node_allocator>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
+    __hash_table& operator=(__hash_table&& __u);
 #endif
    template <class _InputIterator>
        void __assign_unique(_InputIterator __first, _InputIterator __last);
@@ -577,7 +540,7 @@ public:
        void __assign_multi(_InputIterator __first, _InputIterator __last);

    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
+    size_type max_size() const
    {
        return allocator_traits<__pointer_allocator>::max_size(
            __bucket_list_.get_deleter().__alloc());
@@ -614,21 +577,21 @@ public:
    iterator __insert_multi(const_iterator __p, const value_type& __x);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-    void clear() _NOEXCEPT;
+    void clear();
    void rehash(size_type __n);
    _LIBCPP_INLINE_VISIBILITY void reserve(size_type __n)
        {rehash(static_cast<size_type>(ceil(__n / max_load_factor())));}

    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT
+    size_type bucket_count() const
    {
        return __bucket_list_.get_deleter().size();
    }

-    iterator       begin() _NOEXCEPT;
-    iterator       end() _NOEXCEPT;
-    const_iterator begin() const _NOEXCEPT;
-    const_iterator end() const _NOEXCEPT;
+    iterator       begin();
+    iterator       end();
+    const_iterator begin() const;
+    const_iterator end() const;

    template <class _Key>
        _LIBCPP_INLINE_VISIBILITY
@@ -649,7 +612,7 @@ public:
        size_type __erase_unique(const _Key& __k);
    template <class _Key>
        size_type __erase_multi(const _Key& __k);
-    __node_holder remove(const_iterator __p) _NOEXCEPT;
+    __node_holder remove(const_iterator __p);

    template <class _Key>
        size_type __count_unique(const _Key& __k) const;
@@ -670,26 +633,19 @@ public:
        pair<const_iterator, const_iterator>
        __equal_range_multi(const _Key& __k) const;

-    void swap(__hash_table& __u)
-        _NOEXCEPT_(
-            (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<__pointer_allocator>::value) &&
-            (!__node_traits::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<__node_allocator>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
+    void swap(__hash_table& __u);

    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT
+    size_type max_bucket_count() const
        {return __bucket_list_.get_deleter().__alloc().max_size();}
    size_type bucket_size(size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY float load_factor() const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY float load_factor() const
    {
        size_type __bc = bucket_count();
        return __bc != 0 ? (float)size() / __bc : 0.f;
    }
-    _LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) _NOEXCEPT
-        {max_load_factor() = _VSTD::max(__mlf, load_factor());}
+    _LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf)
+        {max_load_factor() = _STD::max(__mlf, load_factor());}

    _LIBCPP_INLINE_VISIBILITY local_iterator       begin(size_type __n)
        {return local_iterator(__bucket_list_[__n], __n, bucket_count());}
@@ -722,40 +678,25 @@ private:
        void __copy_assign_alloc(const __hash_table& __u, false_type) {}

    void __move_assign(__hash_table& __u, false_type);
-    void __move_assign(__hash_table& __u, true_type)
-        _NOEXCEPT_(
-            is_nothrow_move_assignable<__node_allocator>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__hash_table& __u)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_move_assignment::value ||
-            (is_nothrow_move_assignable<__pointer_allocator>::value &&
-             is_nothrow_move_assignable<__node_allocator>::value))
+    void __move_assign(__hash_table& __u, true_type);
+    _LIBCPP_INLINE_VISIBILITY void __move_assign_alloc(__hash_table& __u)
        {__move_assign_alloc(__u, integral_constant<bool,
             __node_traits::propagate_on_container_move_assignment::value>());}
    _LIBCPP_INLINE_VISIBILITY
    void __move_assign_alloc(__hash_table& __u, true_type)
-        _NOEXCEPT_(
-            is_nothrow_move_assignable<__pointer_allocator>::value &&
-            is_nothrow_move_assignable<__node_allocator>::value)
    {
        __bucket_list_.get_deleter().__alloc() =
-                _VSTD::move(__u.__bucket_list_.get_deleter().__alloc());
-        __node_alloc() = _VSTD::move(__u.__node_alloc());
+                _STD::move(__u.__bucket_list_.get_deleter().__alloc());
+        __node_alloc() = _STD::move(__u.__node_alloc());
    }
    _LIBCPP_INLINE_VISIBILITY
-        void __move_assign_alloc(__hash_table&, false_type) _NOEXCEPT {}
+        void __move_assign_alloc(__hash_table&, false_type) {}

    template <class _A>
    _LIBCPP_INLINE_VISIBILITY
    static
    void
    __swap_alloc(_A& __x, _A& __y)
-        _NOEXCEPT_(
-            !allocator_traits<_A>::propagate_on_container_swap::value ||
-            __is_nothrow_swappable<_A>::value)
    {
        __swap_alloc(__x, __y,
                     integral_constant<bool,
@@ -768,9 +709,8 @@ private:
    static
    void
    __swap_alloc(_A& __x, _A& __y, true_type)
-        _NOEXCEPT_(__is_nothrow_swappable<_A>::value)
    {
-        using _VSTD::swap;
+        using _STD::swap;
        swap(__x, __y);
    }

@@ -778,20 +718,15 @@ private:
    _LIBCPP_INLINE_VISIBILITY
    static
    void
-    __swap_alloc(_A& __x, _A& __y, false_type) _NOEXCEPT {}
+    __swap_alloc(_A& __x, _A& __y, false_type) {}

-    void __deallocate(__node_pointer __np) _NOEXCEPT;
-    __node_pointer __detach() _NOEXCEPT;
+    void __deallocate(__node_pointer __np);
+    __node_pointer __detach();
 };

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table()
-    _NOEXCEPT_(
-        is_nothrow_default_constructible<__bucket_list>::value &&
-        is_nothrow_default_constructible<__first_node>::value &&
-        is_nothrow_default_constructible<hasher>::value &&
-        is_nothrow_default_constructible<key_equal>::value)
    : __p2_(0),
      __p3_(1.0f)
 {
@@ -855,20 +790,15 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(const __hash_table& __u,

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__bucket_list>::value &&
-            is_nothrow_move_constructible<__first_node>::value &&
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value)
-    : __bucket_list_(_VSTD::move(__u.__bucket_list_)),
-      __p1_(_VSTD::move(__u.__p1_)),
-      __p2_(_VSTD::move(__u.__p2_)),
-      __p3_(_VSTD::move(__u.__p3_))
+    : __bucket_list_(_STD::move(__u.__bucket_list_)),
+      __p1_(_STD::move(__u.__p1_)),
+      __p2_(_STD::move(__u.__p2_)),
+      __p3_(_STD::move(__u.__p3_))
 {
    if (size() > 0)
    {
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_VSTD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
        __u.__p1_.first().__next_ = nullptr;
        __u.size() = 0;
    }
@@ -879,8 +809,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, _VSTD::move(__u.hash_function())),
-      __p3_(_VSTD::move(__u.__p3_))
+      __p2_(0, _STD::move(__u.hash_function())),
+      __p3_(_STD::move(__u.__p3_))
 {
    if (__a == allocator_type(__u.__node_alloc()))
    {
@@ -892,7 +822,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>(_VSTD::addressof(__p1_.first()));
+                static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
            size() = __u.size();
            __u.size() = 0;
        }
@@ -940,13 +870,12 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(const __hash_table& __u)
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)
-    _NOEXCEPT
 {
    __node_allocator& __na = __node_alloc();
    while (__np != nullptr)
    {
        __node_pointer __next = __np->__next_;
-        __node_traits::destroy(__na, _VSTD::addressof(__np->__value_));
+        __node_traits::destroy(__na, _STD::addressof(__np->__value_));
        __node_traits::deallocate(__na, __np, 1);
        __np = __next;
    }
@@ -954,7 +883,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_pointer
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach() _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::__detach()
 {
    size_type __bc = bucket_count();
    for (size_type __i = 0; __i < __bc; ++__i)
@@ -971,10 +900,6 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
        __hash_table& __u, true_type)
-    _NOEXCEPT_(
-        is_nothrow_move_assignable<__node_allocator>::value &&
-        is_nothrow_move_assignable<hasher>::value &&
-        is_nothrow_move_assignable<key_equal>::value)
 {
    clear();
    __bucket_list_.reset(__u.__bucket_list_.release());
@@ -982,14 +907,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() = _VSTD::move(__u.hash_function());
+    hash_function() = _STD::move(__u.hash_function());
    max_load_factor() = __u.max_load_factor();
-    key_eq() = _VSTD::move(__u.key_eq());
+    key_eq() = _STD::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>(_VSTD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
        __u.__p1_.first().__next_ = nullptr;
        __u.size() = 0;
    }
@@ -1004,8 +929,8 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
        __move_assign(__u, true_type());
    else
    {
-        hash_function() = _VSTD::move(__u.hash_function());
-        key_eq() = _VSTD::move(__u.key_eq());
+        hash_function() = _STD::move(__u.hash_function());
+        key_eq() = _STD::move(__u.key_eq());
        max_load_factor() = __u.max_load_factor();
        if (bucket_count() != 0)
        {
@@ -1017,7 +942,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
                const_iterator __i = __u.begin();
                while (__cache != nullptr && __u.size() != 0)
                {
-                    __cache->__value_ = _VSTD::move(__u.remove(__i++)->__value_);
+                    __cache->__value_ = _STD::move(__u.remove(__i++)->__value_);
                    __node_pointer __next = __cache->__next_;
                    __node_insert_multi(__cache);
                    __cache = __next;
@@ -1036,7 +961,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
        while (__u.size() != 0)
        {
            __node_holder __h =
-                    __construct_node(_VSTD::move(__u.remove(__i++)->__value_));
+                    __construct_node(_STD::move(__u.remove(__i++)->__value_));
            __node_insert_multi(__h.get());
            __h.release();
        }
@@ -1047,11 +972,6 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 __hash_table<_Tp, _Hash, _Equal, _Alloc>&
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::operator=(__hash_table&& __u)
-    _NOEXCEPT_(
-        __node_traits::propagate_on_container_move_assignment::value &&
-        is_nothrow_move_assignable<__node_allocator>::value &&
-        is_nothrow_move_assignable<hasher>::value &&
-        is_nothrow_move_assignable<key_equal>::value)
 {
    __move_assign(__u, integral_constant<bool,
                  __node_traits::propagate_on_container_move_assignment::value>());
@@ -1131,7 +1051,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__assign_multi(_InputIterator __first,
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin()
 {
    return iterator(__p1_.first().__next_);
 }
@@ -1139,7 +1059,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() _NOEXCEPT
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::end()
 {
    return iterator(nullptr);
 }
@@ -1147,7 +1067,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::end() _NOEXCEPT
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const
 {
    return const_iterator(__p1_.first().__next_);
 }
@@ -1155,21 +1075,21 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::begin() const _NOEXCEPT
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::const_iterator
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::end() const
 {
    return const_iterator(nullptr);
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::clear() _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::clear()
 {
    if (size() > 0)
    {
        __deallocate(__p1_.first().__next_);
        __p1_.first().__next_ = nullptr;
        size_type __bc = bucket_count();
-        for (size_type __i = 0; __i < __bc; ++__i)
+        for (size_type __i; __i < __bc; ++__i)
            __bucket_list_[__i] = nullptr;
        size() = 0;
    }
@@ -1202,7 +1122,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_insert_unique(__node_pointer __
    {
        if (size()+1 > __bc * max_load_factor() || __bc == 0)
        {
-            rehash(_VSTD::max<size_type>(2 * __bc + 1,
+            rehash(_STD::max<size_type>(2 * __bc + 1,
                           size_type(ceil(float(size() + 1) / max_load_factor()))));
            __bc = bucket_count();
            __chash = __nd->__hash_ % __bc;
@@ -1211,7 +1131,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>(_VSTD::addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
            __nd->__next_ = __pn->__next_;
            __pn->__next_ = __nd;
            // fix up __bucket_list_
@@ -1241,7 +1161,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(_VSTD::max<size_type>(2 * __bc + 1,
+        rehash(_STD::max<size_type>(2 * __bc + 1,
                       size_type(ceil(float(size() + 1) / max_load_factor()))));
        __bc = bucket_count();
    }
@@ -1249,7 +1169,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>(_VSTD::addressof(__p1_.first()));
+        __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
        __cp->__next_ = __pn->__next_;
        __pn->__next_ = __cp;
        // fix up __bucket_list_
@@ -1302,7 +1222,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(_VSTD::max<size_type>(2 * __bc + 1,
+            rehash(_STD::max<size_type>(2 * __bc + 1,
                           size_type(ceil(float(size() + 1) / max_load_factor()))));
            __bc = bucket_count();
        }
@@ -1346,7 +1266,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(_VSTD::max<size_type>(2 * __bc + 1,
+            rehash(_STD::max<size_type>(2 * __bc + 1,
                           size_type(ceil(float(size() + 1) / max_load_factor()))));
            __bc = bucket_count();
            __chash = __hash % __bc;
@@ -1355,7 +1275,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>(_VSTD::addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
            __h->__next_ = __pn->__next_;
            __pn->__next_ = __h.get();
            // fix up __bucket_list_
@@ -1385,7 +1305,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(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
    pair<iterator, bool> __r = __node_insert_unique(__h.get());
    if (__r.second)
        __h.release();
@@ -1397,7 +1317,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(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
    iterator __r = __node_insert_multi(__h.get());
    __h.release();
    return __r;
@@ -1409,7 +1329,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(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
    iterator __r = __node_insert_multi(__p, __h.get());
    __h.release();
    return __r;
@@ -1422,7 +1342,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(_VSTD::forward<_P>(__x));
+    __node_holder __h = __construct_node(_STD::forward<_P>(__x));
    pair<iterator, bool> __r = __node_insert_unique(__h.get());
    if (__r.second)
        __h.release();
@@ -1438,7 +1358,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(_VSTD::forward<_P>(__x));
+    __node_holder __h = __construct_node(_STD::forward<_P>(__x));
    iterator __r = __node_insert_multi(__h.get());
    __h.release();
    return __r;
@@ -1450,7 +1370,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(_VSTD::forward<_P>(__x));
+    __node_holder __h = __construct_node(_STD::forward<_P>(__x));
    iterator __r = __node_insert_multi(__p, __h.get());
    __h.release();
    return __r;
@@ -1485,13 +1405,13 @@ template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::rehash(size_type __n)
 {
-    __n = __next_prime(_VSTD::max<size_type>(__n, size() > 0));
+    __n = __next_prime(_STD::max<size_type>(__n, size() > 0));
    size_type __bc = bucket_count();
    if (__n > __bc)
        __rehash(__n);
    else
    {
-        __n = _VSTD::max<size_type>
+        __n = _STD::max<size_type>
              (
                  __n,
                  __next_prime(size_t(ceil(float(size()) / max_load_factor())))
@@ -1513,7 +1433,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>(_VSTD::addressof(__p1_.first())));
+        __node_pointer __pp(static_cast<__node_pointer>(_STD::addressof(__p1_.first())));
        __node_pointer __cp = __pp->__next_;
        if (__cp != nullptr)
        {
@@ -1613,7 +1533,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, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = hash_function()(__h->__value_);
    __h->__next_ = nullptr;
@@ -1629,11 +1549,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, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::move(__v));
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = __hash;
    __h->__next_ = nullptr;
-    return _VSTD::move(__h);
+    return _STD::move(__h);
 }

 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1644,11 +1564,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, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = hash_function()(__h->__value_);
    __h->__next_ = nullptr;
-    return _VSTD::move(__h);
+    return _STD::move(__h);
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1660,11 +1580,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, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = __hash;
    __h->__next_ = nullptr;
-    return _VSTD::move(__h);
+    return _STD::move(__h);
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1725,7 +1645,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__erase_multi(const _Key& __k)

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 typename __hash_table<_Tp, _Hash, _Equal, _Alloc>::__node_holder
-__hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
+__hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p)
 {
    // current node
    __node_pointer __cn = const_cast<__node_pointer>(__p.__node_);
@@ -1738,7 +1658,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 == _VSTD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
+    if (__pn == _STD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
    {
        if (__cn->__next_ == nullptr || __cn->__next_->__hash_ % __bc != __chash)
            __bucket_list_[__chash] = nullptr;
@@ -1754,7 +1674,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p) _NOEXCEPT
    __pn->__next_ = __cn->__next_;
    __cn->__next_ = nullptr;
    --size();
-    return __node_holder(__cn, _D(__node_alloc(), true));
+    return __node_holder(__cn, _D(__node_alloc()));
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1856,32 +1776,25 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__equal_range_multi(
 template <class _Tp, class _Hash, class _Equal, class _Alloc>
 void
 __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
-    _NOEXCEPT_(
-        (!allocator_traits<__pointer_allocator>::propagate_on_container_swap::value ||
-         __is_nothrow_swappable<__pointer_allocator>::value) &&
-        (!__node_traits::propagate_on_container_swap::value ||
-         __is_nothrow_swappable<__node_allocator>::value) &&
-        __is_nothrow_swappable<hasher>::value &&
-        __is_nothrow_swappable<key_equal>::value)
 {
    {
    __node_pointer_pointer __npp = __bucket_list_.release();
    __bucket_list_.reset(__u.__bucket_list_.release());
    __u.__bucket_list_.reset(__npp);
    }
-    _VSTD::swap(__bucket_list_.get_deleter().size(), __u.__bucket_list_.get_deleter().size());
+    _STD::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());
-    _VSTD::swap(__p1_.first().__next_, __u.__p1_.first().__next_);
+    _STD::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>(_VSTD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
    if (__u.size() > 0)
        __u.__bucket_list_[__u.__p1_.first().__next_->__hash_ % __u.bucket_count()] =
-            static_cast<__node_pointer>(_VSTD::addressof(__u.__p1_.first()));
+            static_cast<__node_pointer>(_STD::addressof(__u.__p1_.first()));
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
@@ -1901,16 +1814,6 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::bucket_size(size_type __n) const
    return __r;
 }

-template <class _Tp, class _Hash, class _Equal, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__hash_table<_Tp, _Hash, _Equal, _Alloc>& __x,
-     __hash_table<_Tp, _Hash, _Equal, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP__HASH_TABLE
--- a/include/__locale
+++ b/include/__locale
@@ -19,11 +19,7 @@
 #include <cstdint>
 #include <cctype>
 #include <locale.h>
-#if _WIN32
-# include <support/win32/locale_win32.h>
-#elif (__GLIBC__ || __APPLE__ || __FreeBSD__)
-# include <xlocale.h>
-#endif  // _WIN32 || __GLIBC__ || __APPLE__ || __FreeBSD_
+#include <xlocale.h>

 #pragma GCC system_header

@@ -31,7 +27,7 @@ _LIBCPP_BEGIN_NAMESPACE_STD

 class locale;

-template <class _Facet> bool has_facet(const locale&) _NOEXCEPT;
+template <class _Facet> bool has_facet(const locale&) throw();
 template <class _Facet> const _Facet& use_facet(const locale&);

 class _LIBCPP_VISIBLE locale
@@ -53,8 +49,8 @@ public:
        all = collate | ctype | monetary | numeric | time | messages;

    // construct/copy/destroy:
-    locale()  _NOEXCEPT;
-    locale(const locale&)  _NOEXCEPT;
+    locale() throw();
+    locale(const locale&) throw();
    explicit locale(const char*);
    explicit locale(const string&);
    locale(const locale&, const char*, category);
@@ -63,9 +59,9 @@ public:
        _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
    locale(const locale&, const locale&, category);

-    ~locale();
+    ~locale() throw();

-    const locale& operator=(const locale&)  _NOEXCEPT;
+    const locale& operator=(const locale&) throw();

    template <class _Facet> locale combine(const locale&) const;

@@ -90,7 +86,7 @@ private:
    bool has_facet(id&) const;
    const facet* use_facet(id&) const;

-    template <class _Facet> friend bool has_facet(const locale&)  _NOEXCEPT;
+    template <class _Facet> friend bool has_facet(const locale&) throw();
    template <class _Facet> friend const _Facet& use_facet(const locale&);
 };

@@ -107,7 +103,7 @@ protected:
 //    facet(const facet&) = delete;     // effectively done in __shared_count
 //    void operator=(const facet&) = delete;
 private:
-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 };

 class _LIBCPP_VISIBLE locale::id
@@ -141,16 +137,16 @@ locale
 locale::combine(const locale& __other) const
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    if (!_VSTD::has_facet<_Facet>(__other))
+    if (!_STD::has_facet<_Facet>(__other))
        throw runtime_error("locale::combine: locale missing facet");
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    return locale(*this, &const_cast<_Facet&>(_VSTD::use_facet<_Facet>(__other)));
+    return locale(*this, &const_cast<_Facet&>(_STD::use_facet<_Facet>(__other)));
 }

 template <class _Facet>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-has_facet(const locale& __l)  _NOEXCEPT
+has_facet(const locale& __l) throw()
 {
    return __l.has_facet(_Facet::id);
 }
@@ -231,18 +227,18 @@ collate<_CharT>::do_compare(const char_type* __lo1, const char_type* __hi1,

 template <class _CharT>
 long
-collate<_CharT>::do_hash(const char_type* __lo, const char_type* __hi) const
+collate<_CharT>::do_hash(const char_type* lo, const char_type* hi) const
 {
-    size_t __h = 0;
-    const size_t __sr = __CHAR_BIT__ * sizeof(size_t) - 8;
-    const size_t __mask = size_t(0xF) << (__sr + 4);
-    for(const char_type* __p = __lo; __p != __hi; ++__p)
+    size_t h = 0;
+    const size_t sr = __CHAR_BIT__ * sizeof(size_t) - 8;
+    const size_t mask = size_t(0xF) << (sr + 4);
+    for(const char_type* p = lo; p != hi; ++p)
    {
-        __h = (__h << 4) + *__p;
-        size_t __g = __h & __mask;
-        __h ^= __g | (__g >> __sr);
+        h = (h << 4) + *p;
+        size_t g = h & mask;
+        h ^= g | (g >> sr);
    }
-    return static_cast<long>(__h);
+    return static_cast<long>(h);
 }

 extern template class _LIBCPP_VISIBLE collate<char>;
@@ -296,7 +292,7 @@ bool
 locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
                   const basic_string<_CharT, _Traits, _Allocator>& __y) const
 {
-    return _VSTD::use_facet<_VSTD::collate<_CharT> >(*this).compare(
+    return _STD::use_facet<_STD::collate<_CharT> >(*this).compare(
                                       __x.data(), __x.data() + __x.size(),
                                       __y.data(), __y.data() + __y.size()) < 0;
 }
@@ -306,36 +302,9 @@ locale::operator()(const basic_string<_CharT, _Traits, _Allocator>& __x,
 class _LIBCPP_VISIBLE ctype_base
 {
 public:
-#if __GLIBC__
-    typedef unsigned short mask;
-    static const mask space  = _ISspace;
-    static const mask print  = _ISprint;
-    static const mask cntrl  = _IScntrl;
-    static const mask upper  = _ISupper;
-    static const mask lower  = _ISlower;
-    static const mask alpha  = _ISalpha;
-    static const mask digit  = _ISdigit;
-    static const mask punct  = _ISpunct;
-    static const mask xdigit = _ISxdigit;
-    static const mask blank  = _ISblank;
-#elif _WIN32
-    typedef unsigned short mask;
-    static const mask space  = _SPACE;
-    static const mask print  = _BLANK|_PUNCT|_ALPHA|_DIGIT;
-    static const mask cntrl  = _CONTROL;
-    static const mask upper  = _UPPER;
-    static const mask lower  = _LOWER;
-    static const mask alpha  = _ALPHA;
-    static const mask digit  = _DIGIT;
-    static const mask punct  = _PUNCT;
-    static const mask xdigit = _HEX;
-    static const mask blank  = _BLANK;
-#elif (__APPLE__ || __FreeBSD__)
-#if __APPLE__
    typedef __uint32_t mask;
-#elif __FreeBSD__
-    typedef unsigned long mask;
-#endif
+
+#if __APPLE__
    static const mask space  = _CTYPE_S;
    static const mask print  = _CTYPE_R;
    static const mask cntrl  = _CTYPE_C;
@@ -346,19 +315,18 @@ public:
    static const mask punct  = _CTYPE_P;
    static const mask xdigit = _CTYPE_X;
    static const mask blank  = _CTYPE_B;
-#else  // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__
-    typedef unsigned long mask;
-    static const mask space  = 1<<0;
-    static const mask print  = 1<<1;
-    static const mask cntrl  = 1<<2;
-    static const mask upper  = 1<<3;
-    static const mask lower  = 1<<4;
-    static const mask alpha  = 1<<5;
-    static const mask digit  = 1<<6;
-    static const mask punct  = 1<<7;
-    static const mask xdigit = 1<<8;
-    static const mask blank  = 1<<9;
-#endif  // __GLIBC__ || _WIN32 || __APPLE__ || __FreeBSD__
+#else  // __APPLE__
+    static const mask space  = _ISspace;
+    static const mask print  = _ISprint;
+    static const mask cntrl  = _IScntrl;
+    static const mask upper  = _ISupper;
+    static const mask lower  = _ISlower;
+    static const mask alpha  = _ISalpha;
+    static const mask digit  = _ISdigit;
+    static const mask punct  = _ISpunct;
+    static const mask xdigit = _ISxdigit;
+    static const mask blank  = _ISblank;
+#endif  // __APPLE__
    static const mask alnum  = alpha | digit;
    static const mask graph  = alnum | punct;

@@ -567,12 +535,8 @@ public:
 #else
    static const size_t table_size = 256;  // FIXME: Don't hardcode this.
 #endif
-    _LIBCPP_ALWAYS_INLINE const mask* table() const  _NOEXCEPT {return __tab_;}
-    static const mask* classic_table()  _NOEXCEPT;
-#if defined(__GLIBC__)
-    static const int* __classic_upper_table() _NOEXCEPT;
-    static const int* __classic_lower_table() _NOEXCEPT;
-#endif
+    _LIBCPP_ALWAYS_INLINE const mask* table() const throw() {return __tab_;}
+    static const mask* classic_table() throw();

 protected:
    ~ctype();
@@ -791,13 +755,13 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
    {
        return do_encoding();
    }

    _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
    {
        return do_always_noconv();
    }
@@ -809,7 +773,7 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
    {
        return do_max_length();
    }
@@ -831,10 +795,10 @@ protected:
                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
    virtual result do_unshift(state_type& __st,
                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
    virtual int do_length(state_type& __st, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };

 // template <> class codecvt<wchar_t, char, mbstate_t>
@@ -876,13 +840,13 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
    {
        return do_encoding();
    }

    _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
    {
        return do_always_noconv();
    }
@@ -894,7 +858,7 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
    {
        return do_max_length();
    }
@@ -914,10 +878,10 @@ protected:
                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
    virtual result do_unshift(state_type& __st,
                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };

 // template <> class codecvt<char16_t, char, mbstate_t>
@@ -960,13 +924,13 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
    {
        return do_encoding();
    }

    _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
    {
        return do_always_noconv();
    }
@@ -978,7 +942,7 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
    {
        return do_max_length();
    }
@@ -1000,10 +964,10 @@ protected:
                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
    virtual result do_unshift(state_type& __st,
                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };

 // template <> class codecvt<char32_t, char, mbstate_t>
@@ -1046,13 +1010,13 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int encoding() const  _NOEXCEPT
+    int encoding() const throw()
    {
        return do_encoding();
    }

    _LIBCPP_ALWAYS_INLINE
-    bool always_noconv() const  _NOEXCEPT
+    bool always_noconv() const throw()
    {
        return do_always_noconv();
    }
@@ -1064,7 +1028,7 @@ public:
    }

    _LIBCPP_ALWAYS_INLINE
-    int max_length() const  _NOEXCEPT
+    int max_length() const throw()
    {
        return do_max_length();
    }
@@ -1086,10 +1050,10 @@ protected:
                         intern_type* __to, intern_type* __to_end, intern_type*& __to_nxt) const;
    virtual result do_unshift(state_type& __st,
                              extern_type* __to, extern_type* __to_end, extern_type*& __to_nxt) const;
-    virtual int do_encoding() const  _NOEXCEPT;
-    virtual bool do_always_noconv() const  _NOEXCEPT;
+    virtual int do_encoding() const throw();
+    virtual bool do_always_noconv() const throw();
    virtual int do_length(state_type&, const extern_type* __frm, const extern_type* __end, size_t __mx) const;
-    virtual int do_max_length() const  _NOEXCEPT;
+    virtual int do_max_length() const throw();
 };

 // template <class _InternT, class _ExternT, class _StateT> class codecvt_byname
--- a/include/__mutex_base
+++ b/include/__mutex_base
@@ -21,8 +21,8 @@
 #ifdef _LIBCPP_SHARED_LOCK

 namespace ting {
-template <class _Mutex> class shared_lock;
-template <class _Mutex> class upgrade_lock;
+template <class> class shared_lock;
+template <class> class upgrade_lock;
 }

 #endif  // _LIBCPP_SHARED_LOCK
@@ -190,8 +190,8 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    void swap(unique_lock& __u)
    {
-        _VSTD::swap(__m_, __u.__m_);
-        _VSTD::swap(__owns_, __u.__owns_);
+        _STD::swap(__m_, __u.__m_);
+        _STD::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,
-                      _VSTD::move(__pred));
+                      _STD::move(__pred));
 }

 _LIBCPP_END_NAMESPACE_STD
--- a/include/__split_buffer
+++ b/include/__split_buffer
@@ -47,36 +47,29 @@ public:
    typedef typename add_lvalue_reference<allocator_type>::type __alloc_ref;
    typedef typename add_lvalue_reference<allocator_type>::type __alloc_const_ref;

-    _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc() _NOEXCEPT         {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const _NOEXCEPT   {return __end_cap_.second();}
-    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap() _NOEXCEPT       {return __end_cap_.first();}
-    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const _NOEXCEPT {return __end_cap_.first();}
+    _LIBCPP_INLINE_VISIBILITY __alloc_rr&           __alloc()         {return __end_cap_.second();}
+    _LIBCPP_INLINE_VISIBILITY const __alloc_rr&     __alloc() const   {return __end_cap_.second();}
+    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap()       {return __end_cap_.first();}
+    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const {return __end_cap_.first();}

-    __split_buffer()
-        _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value);
+    __split_buffer();
    explicit __split_buffer(__alloc_rr& __a);
    explicit __split_buffer(const __alloc_rr& __a);
    __split_buffer(size_type __cap, size_type __start, __alloc_rr& __a);
    ~__split_buffer();

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __split_buffer(__split_buffer&& __c)
-        _NOEXCEPT_(is_nothrow_move_constructible<allocator_type>::value);
+    __split_buffer(__split_buffer&& __c);
    __split_buffer(__split_buffer&& __c, const __alloc_rr& __a);
-    __split_buffer& operator=(__split_buffer&& __c)
-        _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
-                is_nothrow_move_assignable<allocator_type>::value) ||
-               !__alloc_traits::propagate_on_container_move_assignment::value);
+    __split_buffer& operator=(__split_buffer&& __c);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-    _LIBCPP_INLINE_VISIBILITY       iterator begin() _NOEXCEPT       {return __begin_;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __begin_;}
-    _LIBCPP_INLINE_VISIBILITY       iterator end() _NOEXCEPT         {return __end_;}
-    _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT   {return __end_;}
+    _LIBCPP_INLINE_VISIBILITY       iterator begin()       {return __begin_;}
+    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return __begin_;}
+    _LIBCPP_INLINE_VISIBILITY       iterator end()         {return __end_;}
+    _LIBCPP_INLINE_VISIBILITY const_iterator end() const   {return __end_;}

-    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT
-        {__destruct_at_end(__begin_);}
+    _LIBCPP_INLINE_VISIBILITY void clear() {__destruct_at_end(__begin_);}
    _LIBCPP_INLINE_VISIBILITY size_type size() const {return static_cast<size_type>(__end_ - __begin_);}
    _LIBCPP_INLINE_VISIBILITY bool empty()     const {return __end_ == __begin_;}
    _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __first_);}
@@ -89,7 +82,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY const_reference back() const  {return *(__end_ - 1);}

    void reserve(size_type __n);
-    void shrink_to_fit() _NOEXCEPT;
+    void shrink_to_fit();
    void push_front(const_reference __x);
    void push_back(const_reference __x);
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
@@ -127,47 +120,40 @@ public:
        void __destruct_at_begin(pointer __new_begin, false_type);
        void __destruct_at_begin(pointer __new_begin, true_type);

-    _LIBCPP_INLINE_VISIBILITY
-    void __destruct_at_end(pointer __new_last) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY void __destruct_at_end(pointer __new_last)
        {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
-        void __destruct_at_end(pointer __new_last, false_type) _NOEXCEPT;
-        void __destruct_at_end(pointer __new_last, true_type) _NOEXCEPT;
+        void __destruct_at_end(pointer __new_last, false_type);
+        void __destruct_at_end(pointer __new_last, true_type);

-    void swap(__split_buffer& __x)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value);
+    void swap(__split_buffer& __x);

    bool __invariants() const;

 private:
    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__split_buffer& __c, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
+    void __move_assign_alloc(const __split_buffer& __c, true_type)
        {
-            __alloc() = _VSTD::move(__c.__alloc());
+            __alloc() = _STD::move(__c.__alloc());
        }

    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__split_buffer& __c, false_type) _NOEXCEPT
+    void __move_assign_alloc(const __split_buffer& __c, false_type)
        {}

    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value)
        {__swap_alloc(__x, __y, integral_constant<bool,
                      __alloc_traits::propagate_on_container_swap::value>());}

    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, true_type)
-        _NOEXCEPT_(__is_nothrow_swappable<__alloc_rr>::value)
        {
-            using _VSTD::swap;
+            using _STD::swap;
            swap(__x, __y);
        }

    _LIBCPP_INLINE_VISIBILITY
-    static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, false_type) _NOEXCEPT
+    static void __swap_alloc(__alloc_rr& __x, __alloc_rr& __y, false_type)
        {}
 };

@@ -208,7 +194,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
    __alloc_rr& __a = this->__alloc();
    do
    {
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_));
+        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), value_type());
        ++this->__end_;
        --__n;
    } while (__n > 0);
@@ -227,7 +213,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_referen
    __alloc_rr& __a = this->__alloc();
    do
    {
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), __x);
+        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), __x);
        ++this->__end_;
        --__n;
    } while (__n > 0);
@@ -249,14 +235,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 = _VSTD::max<size_type>(2 * __old_cap, 8);
+            size_type __new_cap = _STD::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(),
-                        _VSTD::__to_raw_pointer(__buf.__end_), _VSTD::move(*__p));
+                        _STD::__to_raw_pointer(__buf.__end_), _STD::move(*__p));
            swap(__buf);
        }
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
+        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
        ++this->__end_;
    }
 }
@@ -273,7 +259,7 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(_ForwardIterator __first, _F
    __alloc_rr& __a = this->__alloc();
    for (; __first != __last; ++__first)
    {
-        __alloc_traits::construct(__a, _VSTD::__to_raw_pointer(this->__end_), *__first);
+        __alloc_traits::construct(__a, _STD::__to_raw_pointer(this->__end_), *__first);
        ++this->__end_;
    }
 }
@@ -298,7 +284,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_begin(pointer __new_begin, true_t
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type) _NOEXCEPT
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_type)
 {
    while (__new_last < __end_)
        __alloc_traits::destroy(__alloc(), --__end_);
@@ -307,7 +293,7 @@ __split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, false_typ
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 void
-__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type) _NOEXCEPT
+__split_buffer<_Tp, _Allocator>::__destruct_at_end(pointer __new_last, true_type)
 {
    __end_ = __new_last;
 }
@@ -324,7 +310,6 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(size_type __cap, size_type __sta
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 __split_buffer<_Tp, _Allocator>::__split_buffer()
-    _NOEXCEPT_(is_nothrow_default_constructible<allocator_type>::value)
    : __first_(0), __begin_(0), __end_(0), __end_cap_(0)
 {
 }
@@ -355,11 +340,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_(_VSTD::move(__c.__first_)),
-      __begin_(_VSTD::move(__c.__begin_)),
-      __end_(_VSTD::move(__c.__end_)),
-      __end_cap_(_VSTD::move(__c.__end_cap_))
+    : __first_(_STD::move(__c.__first_)),
+      __begin_(_STD::move(__c.__begin_)),
+      __end_(_STD::move(__c.__end_)),
+      __end_cap_(_STD::move(__c.__end_cap_))
 {
    __c.__first_ = nullptr;
    __c.__begin_ = nullptr;
@@ -396,9 +380,6 @@ __split_buffer<_Tp, _Allocator>::__split_buffer(__split_buffer&& __c, const __al
 template <class _Tp, class _Allocator>
 __split_buffer<_Tp, _Allocator>&
 __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
-    _NOEXCEPT_((__alloc_traits::propagate_on_container_move_assignment::value &&
-                is_nothrow_move_assignable<allocator_type>::value) ||
-               !__alloc_traits::propagate_on_container_move_assignment::value)
 {
    clear();
    shrink_to_fit();
@@ -418,13 +399,11 @@ __split_buffer<_Tp, _Allocator>::operator=(__split_buffer&& __c)
 template <class _Tp, class _Allocator>
 void
 __split_buffer<_Tp, _Allocator>::swap(__split_buffer& __x)
-        _NOEXCEPT_(!__alloc_traits::propagate_on_container_swap::value||
-                   __is_nothrow_swappable<__alloc_rr>::value)
 {
-    _VSTD::swap(__first_, __x.__first_);
-    _VSTD::swap(__begin_, __x.__begin_);
-    _VSTD::swap(__end_, __x.__end_);
-    _VSTD::swap(__end_cap(), __x.__end_cap());
+    _STD::swap(__first_, __x.__first_);
+    _STD::swap(__begin_, __x.__begin_);
+    _STD::swap(__end_, __x.__end_);
+    _STD::swap(__end_cap(), __x.__end_cap());
    __swap_alloc(__alloc(), __x.__alloc());
 }

@@ -437,16 +416,16 @@ __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_));
-        _VSTD::swap(__first_, __t.__first_);
-        _VSTD::swap(__begin_, __t.__begin_);
-        _VSTD::swap(__end_, __t.__end_);
-        _VSTD::swap(__end_cap(), __t.__end_cap());
+        _STD::swap(__first_, __t.__first_);
+        _STD::swap(__begin_, __t.__begin_);
+        _STD::swap(__end_, __t.__end_);
+        _STD::swap(__end_cap(), __t.__end_cap());
    }
 }

 template <class _Tp, class _Allocator>
 void
-__split_buffer<_Tp, _Allocator>::shrink_to_fit() _NOEXCEPT
+__split_buffer<_Tp, _Allocator>::shrink_to_fit()
 {
    if (capacity() > size())
    {
@@ -458,10 +437,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_);
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+            _STD::swap(__first_, __t.__first_);
+            _STD::swap(__begin_, __t.__begin_);
+            _STD::swap(__end_, __t.__end_);
+            _STD::swap(__end_cap(), __t.__end_cap());
 #ifndef _LIBCPP_NO_EXCEPTIONS
        }
        catch (...)
@@ -481,7 +460,7 @@ __split_buffer<_Tp, _Allocator>::push_front(const_reference __x)
        {
            difference_type __d = __end_cap() - __end_;
            __d = (__d + 1) / 2;
-            __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
+            __begin_ = _STD::move_backward(__begin_, __end_, __end_ + __d);
            __end_ += __d;
        }
        else
@@ -490,13 +469,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_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+            _STD::swap(__first_, __t.__first_);
+            _STD::swap(__begin_, __t.__begin_);
+            _STD::swap(__end_, __t.__end_);
+            _STD::swap(__end_cap(), __t.__end_cap());
        }
    }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1), __x);
+    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__begin_-1), __x);
    --__begin_;
 }

@@ -512,7 +491,7 @@ __split_buffer<_Tp, _Allocator>::push_front(value_type&& __x)
        {
            difference_type __d = __end_cap() - __end_;
            __d = (__d + 1) / 2;
-            __begin_ = _VSTD::move_backward(__begin_, __end_, __end_ + __d);
+            __begin_ = _STD::move_backward(__begin_, __end_, __end_ + __d);
            __end_ += __d;
        }
        else
@@ -521,14 +500,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_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+            _STD::swap(__first_, __t.__first_);
+            _STD::swap(__begin_, __t.__begin_);
+            _STD::swap(__end_, __t.__end_);
+            _STD::swap(__end_cap(), __t.__end_cap());
        }
    }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__begin_-1),
-            _VSTD::move(__x));
+    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__begin_-1),
+            _STD::move(__x));
    --__begin_;
 }

@@ -545,7 +524,7 @@ __split_buffer<_Tp, _Allocator>::push_back(const_reference __x)
        {
            difference_type __d = __begin_ - __first_;
            __d = (__d + 1) / 2;
-            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
+            __end_ = _STD::move(__begin_, __end_, __begin_ - __d);
            __begin_ -= __d;
        }
        else
@@ -554,13 +533,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_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+            _STD::swap(__first_, __t.__first_);
+            _STD::swap(__begin_, __t.__begin_);
+            _STD::swap(__end_, __t.__end_);
+            _STD::swap(__end_cap(), __t.__end_cap());
        }
    }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_), __x);
+    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_), __x);
    ++__end_;
 }

@@ -576,7 +555,7 @@ __split_buffer<_Tp, _Allocator>::push_back(value_type&& __x)
        {
            difference_type __d = __begin_ - __first_;
            __d = (__d + 1) / 2;
-            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
+            __end_ = _STD::move(__begin_, __end_, __begin_ - __d);
            __begin_ -= __d;
        }
        else
@@ -585,14 +564,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_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+            _STD::swap(__first_, __t.__first_);
+            _STD::swap(__begin_, __t.__begin_);
+            _STD::swap(__end_, __t.__end_);
+            _STD::swap(__end_cap(), __t.__end_cap());
        }
    }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
-            _VSTD::move(__x));
+    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_),
+            _STD::move(__x));
    ++__end_;
 }

@@ -609,7 +588,7 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)
        {
            difference_type __d = __begin_ - __first_;
            __d = (__d + 1) / 2;
-            __end_ = _VSTD::move(__begin_, __end_, __begin_ - __d);
+            __end_ = _STD::move(__begin_, __end_, __begin_ - __d);
            __begin_ -= __d;
        }
        else
@@ -618,14 +597,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_));
-            _VSTD::swap(__first_, __t.__first_);
-            _VSTD::swap(__begin_, __t.__begin_);
-            _VSTD::swap(__end_, __t.__end_);
-            _VSTD::swap(__end_cap(), __t.__end_cap());
+            _STD::swap(__first_, __t.__first_);
+            _STD::swap(__begin_, __t.__begin_);
+            _STD::swap(__end_, __t.__end_);
+            _STD::swap(__end_cap(), __t.__end_cap());
        }
    }
-    __alloc_traits::construct(__alloc(), _VSTD::__to_raw_pointer(__end_),
-                              _VSTD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__alloc(), _STD::__to_raw_pointer(__end_),
+                              _STD::forward<_Args>(__args)...);
    ++__end_;
 }

@@ -633,16 +612,6 @@ __split_buffer<_Tp, _Allocator>::emplace_back(_Args&&... __args)

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-template <class _Tp, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-swap(__split_buffer<_Tp, _Allocator>& __x, __split_buffer<_Tp, _Allocator>& __y)
-        _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
-
 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP_SPLIT_BUFFER
--- a/include/__std_stream
+++ b/include/__std_stream
@@ -97,7 +97,7 @@ typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
    char __extbuf[__limit];
-    int __nread = _VSTD::max(1, __encoding_);
+    int __nread = _STD::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 _VSTD::codecvt_base::ok:
+            case _STD::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 _VSTD::codecvt_base::noconv:
+            case _STD::codecvt_base::noconv:
                __1buf = static_cast<char_type>(__extbuf[0]);
                break;
            }
-        } while (__r == _VSTD::codecvt_base::partial);
+        } while (__r == _STD::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 _VSTD::codecvt_base::ok:
+    case _STD::codecvt_base::ok:
        break;
-    case _VSTD::codecvt_base::noconv:
+    case _STD::codecvt_base::noconv:
        __extbuf[0] = static_cast<char>(__c);
        __enxt = __extbuf + 1;
        break;
--- a/include/__tree
+++ b/include/__tree
@@ -21,19 +21,13 @@

 _LIBCPP_BEGIN_NAMESPACE_STD

-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;
+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;

 /*

@@ -61,7 +55,7 @@ __root, have a non-null __parent_ field.
 template <class _NodePtr>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-__tree_is_left_child(_NodePtr __x) _NOEXCEPT
+__tree_is_left_child(_NodePtr __x)
 {
    return __x == __x->__parent_->__left_;
 }
@@ -127,7 +121,7 @@ __tree_invariant(_NodePtr __root)
 template <class _NodePtr>
 inline _LIBCPP_INLINE_VISIBILITY
 _NodePtr
-__tree_min(_NodePtr __x) _NOEXCEPT
+__tree_min(_NodePtr __x)
 {
    while (__x->__left_ != nullptr)
        __x = __x->__left_;
@@ -139,7 +133,7 @@ __tree_min(_NodePtr __x) _NOEXCEPT
 template <class _NodePtr>
 inline _LIBCPP_INLINE_VISIBILITY
 _NodePtr
-__tree_max(_NodePtr __x) _NOEXCEPT
+__tree_max(_NodePtr __x)
 {
    while (__x->__right_ != nullptr)
        __x = __x->__right_;
@@ -150,7 +144,7 @@ __tree_max(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
 _NodePtr
-__tree_next(_NodePtr __x) _NOEXCEPT
+__tree_next(_NodePtr __x)
 {
    if (__x->__right_ != nullptr)
        return __tree_min(__x->__right_);
@@ -163,7 +157,7 @@ __tree_next(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
 _NodePtr
-__tree_prev(_NodePtr __x) _NOEXCEPT
+__tree_prev(_NodePtr __x)
 {
    if (__x->__left_ != nullptr)
        return __tree_max(__x->__left_);
@@ -176,7 +170,7 @@ __tree_prev(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x != nullptr.
 template <class _NodePtr>
 _NodePtr
-__tree_leaf(_NodePtr __x) _NOEXCEPT
+__tree_leaf(_NodePtr __x)
 {
    while (true)
    {
@@ -200,7 +194,7 @@ __tree_leaf(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x->__right_ != nullptr
 template <class _NodePtr>
 void
-__tree_left_rotate(_NodePtr __x) _NOEXCEPT
+__tree_left_rotate(_NodePtr __x)
 {
    _NodePtr __y = __x->__right_;
    __x->__right_ = __y->__left_;
@@ -220,7 +214,7 @@ __tree_left_rotate(_NodePtr __x) _NOEXCEPT
 // Precondition:  __x->__left_ != nullptr
 template <class _NodePtr>
 void
-__tree_right_rotate(_NodePtr __x) _NOEXCEPT
+__tree_right_rotate(_NodePtr __x)
 {
    _NodePtr __y = __x->__left_;
    __x->__left_ = __y->__right_;
@@ -245,7 +239,7 @@ __tree_right_rotate(_NodePtr __x) _NOEXCEPT
 //                may be different than the value passed in as __root.
 template <class _NodePtr>
 void
-__tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
+__tree_balance_after_insert(_NodePtr __root, _NodePtr __x)
 {
    __x->__is_black_ = __x == __root;
    while (__x != __root && !__x->__parent_->__is_black_)
@@ -315,7 +309,7 @@ __tree_balance_after_insert(_NodePtr __root, _NodePtr __x) _NOEXCEPT
 //                may be different than the value passed in as __root.
 template <class _NodePtr>
 void
-__tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
+__tree_remove(_NodePtr __root, _NodePtr __z)
 {
    // __z will be removed from the tree.  Client still needs to destruct/deallocate it
    // __y is either __z, or if __z has two children, __tree_next(__z).
@@ -500,7 +494,7 @@ __tree_remove(_NodePtr __root, _NodePtr __z) _NOEXCEPT
    }
 }

-template <class _Allocator> class __map_node_destructor;
+template <class> class __map_node_destructor;

 template <class _Allocator>
 class __tree_node_destructor
@@ -520,16 +514,16 @@ public:
    bool __value_constructed;

    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_node_destructor(allocator_type& __na) _NOEXCEPT
+    explicit __tree_node_destructor(allocator_type& __na)
        : __na_(__na),
          __value_constructed(false)
        {}

    _LIBCPP_INLINE_VISIBILITY
-    void operator()(pointer __p) _NOEXCEPT
+    void operator()(pointer __p)
    {
        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -547,7 +541,7 @@ public:
    pointer __left_;

    _LIBCPP_INLINE_VISIBILITY
-    __tree_end_node() _NOEXCEPT : __left_() {}
+    __tree_end_node() : __left_() {}
 };

 template <class _VoidPtr>
@@ -586,8 +580,7 @@ public:
    bool __is_black_;

    _LIBCPP_INLINE_VISIBILITY
-    __tree_node_base() _NOEXCEPT
-        : __right_(), __parent_(), __is_black_(false) {}
+    __tree_node_base() : __right_(), __parent_(), __is_black_(false) {}
 };

 template <class _Tp, class _VoidPtr>
@@ -604,7 +597,7 @@ public:
    template <class ..._Args>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tree_node(_Args&& ...__args)
-            : __value_(_VSTD::forward<_Args>(__args)...) {}
+            : __value_(_STD::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)
@@ -612,8 +605,8 @@ public:
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
 };

-template <class _TreeIterator> class __map_iterator;
-template <class _TreeIterator> class __map_const_iterator;
+template <class> class __map_iterator;
+template <class> class __map_const_iterator;

 template <class _Tp, class _NodePtr, class _DiffType>
 class _LIBCPP_VISIBLE __tree_iterator
@@ -639,7 +632,7 @@ public:
 #endif
                                       pointer;

-    _LIBCPP_INLINE_VISIBILITY __tree_iterator() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY __tree_iterator() {}

    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
    _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return &__ptr_->__value_;}
@@ -669,7 +662,7 @@ public:

 private:
    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+    explicit __tree_iterator(__node_pointer __p) : __ptr_(__p) {}
    template <class, class, class> friend class __tree;
    template <class, class, class> friend class _LIBCPP_VISIBLE __tree_const_iterator;
    template <class> friend class _LIBCPP_VISIBLE __map_iterator;
@@ -723,8 +716,7 @@ private:
                                                 __non_const_iterator;
 public:
    _LIBCPP_INLINE_VISIBILITY
-    __tree_const_iterator(__non_const_iterator __p) _NOEXCEPT
-        : __ptr_(__p.__ptr_) {}
+    __tree_const_iterator(__non_const_iterator __p) : __ptr_(__p.__ptr_) {}

    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return __ptr_->__value_;}
    _LIBCPP_INLINE_VISIBILITY pointer operator->() const {return &__ptr_->__value_;}
@@ -754,8 +746,7 @@ public:

 private:
    _LIBCPP_INLINE_VISIBILITY
-    explicit __tree_const_iterator(__node_pointer __p) _NOEXCEPT
-        : __ptr_(__p) {}
+    explicit __tree_const_iterator(__node_pointer __p) : __ptr_(__p) {}
    template <class, class, class> friend class __tree;
    template <class, class, class, class> friend class _LIBCPP_VISIBLE map;
    template <class, class, class, class> friend class _LIBCPP_VISIBLE multimap;
@@ -814,7 +805,7 @@ private:

 public:
    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __end_node() _NOEXCEPT
+    __node_pointer __end_node()
    {
        return static_cast<__node_pointer>
               (
@@ -822,7 +813,7 @@ public:
               );
    }
    _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer __end_node() const _NOEXCEPT
+    __node_const_pointer __end_node() const
    {
        return static_cast<__node_const_pointer>
               (
@@ -830,45 +821,39 @@ public:
               );
    }
    _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __node_alloc() _NOEXCEPT {return __pair1_.second();}
+          __node_allocator& __node_alloc()       {return __pair1_.second();}
 private:
    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __node_alloc() const _NOEXCEPT
-        {return __pair1_.second();}
+    const __node_allocator& __node_alloc() const {return __pair1_.second();}
    _LIBCPP_INLINE_VISIBILITY
-          __node_pointer& __begin_node() _NOEXCEPT {return __begin_node_;}
+          __node_pointer& __begin_node()         {return __begin_node_;}
    _LIBCPP_INLINE_VISIBILITY
-    const __node_pointer& __begin_node() const _NOEXCEPT {return __begin_node_;}
+    const __node_pointer& __begin_node()   const {return __begin_node_;}
 public:
    _LIBCPP_INLINE_VISIBILITY
-    allocator_type __alloc() const _NOEXCEPT
-        {return allocator_type(__node_alloc());}
+    allocator_type __alloc() const {return allocator_type(__node_alloc());}
 private:
    _LIBCPP_INLINE_VISIBILITY
-          size_type& size() _NOEXCEPT {return __pair3_.first();}
+          size_type& size()                      {return __pair3_.first();}
 public:
    _LIBCPP_INLINE_VISIBILITY
-    const size_type& size() const _NOEXCEPT {return __pair3_.first();}
+    const size_type& size()                const {return __pair3_.first();}
    _LIBCPP_INLINE_VISIBILITY
-          value_compare& value_comp() _NOEXCEPT {return __pair3_.second();}
+          value_compare& value_comp()            {return __pair3_.second();}
    _LIBCPP_INLINE_VISIBILITY
-    const value_compare& value_comp() const _NOEXCEPT
-        {return __pair3_.second();}
+    const value_compare& value_comp()      const {return __pair3_.second();}
 public:
    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer __root() _NOEXCEPT
+    __node_pointer       __root()
        {return static_cast<__node_pointer>      (__end_node()->__left_);}
    _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer __root() const _NOEXCEPT
+    __node_const_pointer __root() const
        {return static_cast<__node_const_pointer>(__end_node()->__left_);}

    typedef __tree_iterator<value_type, __node_pointer, difference_type>             iterator;
    typedef __tree_const_iterator<value_type, __node_const_pointer, difference_type> const_iterator;

-    explicit __tree(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_copy_constructible<value_compare>::value);
+    explicit __tree(const value_compare& __comp);
    explicit __tree(const allocator_type& __a);
    __tree(const value_compare& __comp, const allocator_type& __a);
    __tree(const __tree& __t);
@@ -878,40 +863,28 @@ public:
    template <class _InputIterator>
        void __assign_multi(_InputIterator __first, _InputIterator __last);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    __tree(__tree&& __t)
-        _NOEXCEPT_(
-            is_nothrow_move_constructible<__node_allocator>::value &&
-            is_nothrow_move_constructible<value_compare>::value);
+    __tree(__tree&& __t);
    __tree(__tree&& __t, const allocator_type& __a);
-    __tree& operator=(__tree&& __t)
-        _NOEXCEPT_(
-            __node_traits::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<value_compare>::value &&
-            is_nothrow_move_assignable<__node_allocator>::value);
+    __tree& operator=(__tree&& __t);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    ~__tree();

    _LIBCPP_INLINE_VISIBILITY
-          iterator begin()  _NOEXCEPT {return       iterator(__begin_node());}
+          iterator begin()       {return       iterator(__begin_node());}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return const_iterator(__begin_node());}
+    const_iterator begin() const {return const_iterator(__begin_node());}
    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT {return       iterator(__end_node());}
+          iterator end()         {return       iterator(__end_node());}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return const_iterator(__end_node());}
+    const_iterator end()   const {return const_iterator(__end_node());}

    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-        {return __node_traits::max_size(__node_alloc());}
+    size_type max_size() const {return __node_traits::max_size(__node_alloc());}

-    void clear() _NOEXCEPT;
+    void clear();

-    void swap(__tree& __t)
-        _NOEXCEPT_(
-            __is_nothrow_swappable<value_compare>::value &&
-            (!__node_traits::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<__node_allocator>::value));
+    void swap(__tree& __t);

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -1022,7 +995,7 @@ public:
    typedef __tree_node_destructor<__node_allocator> _D;
    typedef unique_ptr<__node, _D> __node_holder;

-    __node_holder remove(const_iterator __p) _NOEXCEPT;
+    __node_holder remove(const_iterator __p);
 private:
    typename __node_base::pointer&
        __find_leaf_low(typename __node_base::pointer& __parent, const value_type& __v);
@@ -1046,7 +1019,7 @@ private:
        __node_holder __construct_node(const value_type& __v);
 #endif

-    void destroy(__node_pointer __nd) _NOEXCEPT;
+    void destroy(__node_pointer __nd);

    _LIBCPP_INLINE_VISIBILITY
    void __copy_assign_alloc(const __tree& __t)
@@ -1060,42 +1033,31 @@ private:
    void __copy_assign_alloc(const __tree& __t, false_type) {}

    void __move_assign(__tree& __t, false_type);
-    void __move_assign(__tree& __t, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
-                   is_nothrow_move_assignable<__node_allocator>::value);
+    void __move_assign(__tree& __t, true_type);

    _LIBCPP_INLINE_VISIBILITY
    void __move_assign_alloc(__tree& __t)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_move_assignment::value ||
-            is_nothrow_move_assignable<__node_allocator>::value)
        {__move_assign_alloc(__t, integral_constant<bool,
             __node_traits::propagate_on_container_move_assignment::value>());}

    _LIBCPP_INLINE_VISIBILITY
    void __move_assign_alloc(__tree& __t, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {__node_alloc() = _VSTD::move(__t.__node_alloc());}
+        {__node_alloc() = _STD::move(__t.__node_alloc());}
    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__tree& __t, false_type) _NOEXCEPT {}
+    void __move_assign_alloc(__tree& __t, false_type) {}

    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
-        _NOEXCEPT_(
-            !__node_traits::propagate_on_container_swap::value ||
-            __is_nothrow_swappable<__node_allocator>::value)
        {__swap_alloc(__x, __y, integral_constant<bool,
                      __node_traits::propagate_on_container_swap::value>());}
    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, true_type)
-        _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
        {
-            using _VSTD::swap;
+            using _STD::swap;
            swap(__x, __y);
        }
    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y, false_type)
-        _NOEXCEPT
        {}

    __node_pointer __detach();
@@ -1104,9 +1066,6 @@ private:

 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(const value_compare& __comp)
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<__node_allocator>::value &&
-            is_nothrow_copy_constructible<value_compare>::value)
    : __pair3_(0, __comp)
 {
    __begin_node() = __end_node();
@@ -1281,12 +1240,9 @@ __tree<_Tp, _Compare, _Allocator>::__tree(const __tree& __t)

 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t)
-    _NOEXCEPT_(
-        is_nothrow_move_constructible<__node_allocator>::value &&
-        is_nothrow_move_constructible<value_compare>::value)
-    : __begin_node_(_VSTD::move(__t.__begin_node_)),
-      __pair1_(_VSTD::move(__t.__pair1_)),
-      __pair3_(_VSTD::move(__t.__pair3_))
+    : __begin_node_(_STD::move(__t.__begin_node_)),
+      __pair1_(_STD::move(__t.__pair1_)),
+      __pair3_(_STD::move(__t.__pair3_))
 {
    if (size() == 0)
        __begin_node() = __end_node();
@@ -1302,7 +1258,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, _VSTD::move(__t.value_comp()))
+      __pair3_(0, _STD::move(__t.value_comp()))
 {
    if (__a == __t.__alloc())
    {
@@ -1328,14 +1284,12 @@ __tree<_Tp, _Compare, _Allocator>::__tree(__tree&& __t, const allocator_type& __
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<value_compare>::value &&
-               is_nothrow_move_assignable<__node_allocator>::value)
 {
    destroy(static_cast<__node_pointer>(__end_node()->__left_));
    __begin_node_ = __t.__begin_node_;
    __pair1_.first() = __t.__pair1_.first();
    __move_assign_alloc(__t);
-    __pair3_ = _VSTD::move(__t.__pair3_);
+    __pair3_ = _STD::move(__t.__pair3_);
    if (size() == 0)
        __begin_node() = __end_node();
    else
@@ -1355,7 +1309,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
        __move_assign(__t, true_type());
    else
    {
-        value_comp() = _VSTD::move(__t.value_comp());
+        value_comp() = _STD::move(__t.value_comp());
        const_iterator __e = end();
        if (size() != 0)
        {
@@ -1366,7 +1320,7 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
 #endif  // _LIBCPP_NO_EXCEPTIONS
                while (__cache != nullptr && __t.size() != 0)
                {
-                    __cache->__value_ = _VSTD::move(__t.remove(__t.begin())->__value_);
+                    __cache->__value_ = _STD::move(__t.remove(__t.begin())->__value_);
                    __node_pointer __next = __detach(__cache);
                    __node_insert_multi(__cache);
                    __cache = __next;
@@ -1389,18 +1343,13 @@ __tree<_Tp, _Compare, _Allocator>::__move_assign(__tree& __t, false_type)
            }
        }
        while (__t.size() != 0)
-            __insert_multi(__e, _VSTD::move(__t.remove(__t.begin())->__value_));
+            __insert_multi(__e, _STD::move(__t.remove(__t.begin())->__value_));
    }
 }

 template <class _Tp, class _Compare, class _Allocator>
 __tree<_Tp, _Compare, _Allocator>&
 __tree<_Tp, _Compare, _Allocator>::operator=(__tree&& __t)
-    _NOEXCEPT_(
-        __node_traits::propagate_on_container_move_assignment::value &&
-        is_nothrow_move_assignable<value_compare>::value &&
-        is_nothrow_move_assignable<__node_allocator>::value)
-        
 {
    __move_assign(__t, integral_constant<bool,
                  __node_traits::propagate_on_container_move_assignment::value>());
@@ -1417,14 +1366,14 @@ __tree<_Tp, _Compare, _Allocator>::~__tree()

 template <class _Tp, class _Compare, class _Allocator>
 void
-__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd)
 {
    if (__nd != nullptr)
    {
        destroy(static_cast<__node_pointer>(__nd->__left_));
        destroy(static_cast<__node_pointer>(__nd->__right_));
        __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, _VSTD::addressof(__nd->__value_));
+        __node_traits::destroy(__na, _STD::addressof(__nd->__value_));
        __node_traits::deallocate(__na, __nd, 1);
    }
 }
@@ -1432,12 +1381,8 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd) _NOEXCEPT
 template <class _Tp, class _Compare, class _Allocator>
 void
 __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)
-    _NOEXCEPT_(
-        __is_nothrow_swappable<value_compare>::value &&
-        (!__node_traits::propagate_on_container_swap::value ||
-         __is_nothrow_swappable<__node_allocator>::value))
 {
-    using _VSTD::swap;
+    using _STD::swap;
    swap(__begin_node_, __t.__begin_node_);
    swap(__pair1_.first(), __t.__pair1_.first());
    __swap_alloc(__node_alloc(), __t.__node_alloc());
@@ -1454,7 +1399,7 @@ __tree<_Tp, _Compare, _Allocator>::swap(__tree& __t)

 template <class _Tp, class _Compare, class _Allocator>
 void
-__tree<_Tp, _Compare, _Allocator>::clear() _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::clear()
 {
    destroy(__root());
    size() = 0;
@@ -1661,10 +1606,10 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
    else if (value_comp()(*__hint, __v))  // check after
    {
        // *__hint < __v
-        const_iterator __next = _VSTD::next(__hint);
+        const_iterator __next = _STD::next(__hint);
        if (__next == end() || value_comp()(__v, *__next))
        {
-            // *__hint < __v < *_VSTD::next(__hint)
+            // *__hint < __v < *_STD::next(__hint)
            if (__hint.__ptr_->__right_ == nullptr)
            {
                __parent = const_cast<__node_pointer&>(__hint.__ptr_);
@@ -1710,7 +1655,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, _VSTD::addressof(__h->__value_), _VSTD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__value_constructed = true;
    return __h;
 }
@@ -1720,7 +1665,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(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
    __node_base_pointer __parent;
    __node_base_pointer& __child = __find_equal(__parent, __h->__value_);
    __node_pointer __r = static_cast<__node_pointer>(__child);
@@ -1739,7 +1684,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(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::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);
@@ -1756,7 +1701,7 @@ template <class... _Args>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__emplace_multi(_Args&&... __args)
 {
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
    __node_base_pointer __parent;
    __node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
    __insert_node_at(__parent, __child, __h.get());
@@ -1769,7 +1714,7 @@ typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__emplace_hint_multi(const_iterator __p,
                                                        _Args&&... __args)
 {
-    __node_holder __h = __construct_node(_VSTD::forward<_Args>(__args)...);
+    __node_holder __h = __construct_node(_STD::forward<_Args>(__args)...);
    __node_base_pointer __parent;
    __node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
    __insert_node_at(__parent, __child, __h.get());
@@ -1783,7 +1728,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(_VSTD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
    pair<iterator, bool> __r = __node_insert_unique(__h.get());
    if (__r.second)
        __h.release();
@@ -1795,7 +1740,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(_VSTD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
    iterator __r = __node_insert_unique(__p, __h.get());
    if (__r.__ptr_ == __h.get())
        __h.release();
@@ -1807,7 +1752,7 @@ template <class _V>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__insert_multi(_V&& __v)
 {
-    __node_holder __h = __construct_node(_VSTD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
    __node_base_pointer __parent;
    __node_base_pointer& __child = __find_leaf_high(__parent, __h->__value_);
    __insert_node_at(__parent, __child, __h.get());
@@ -1819,7 +1764,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(_VSTD::forward<_V>(__v));
+    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
    __node_base_pointer __parent;
    __node_base_pointer& __child = __find_leaf(__p, __parent, __h->__value_);
    __insert_node_at(__parent, __child, __h.get());
@@ -1834,9 +1779,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, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
-    return _VSTD::move(__h);
+    return _STD::move(__h);
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1962,7 +1907,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*>(_VSTD::addressof(*__p)));
+    __node_traits::destroy(__na, const_cast<value_type*>(_STD::addressof(*__p)));
    __tree_remove(__end_node()->__left_,
                  static_cast<__node_base_pointer>(__np));
    __node_traits::deallocate(__na, __np, 1);
@@ -2064,7 +2009,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 _VSTD::distance(
+            return _STD::distance(
                __lower_bound(__k, static_cast<__node_const_pointer>(__rt->__left_), __rt),
                __upper_bound(__k, static_cast<__node_const_pointer>(__rt->__right_), __result)
            );
@@ -2260,7 +2205,7 @@ __tree<_Tp, _Compare, _Allocator>::__equal_range_multi(const _Key& __k) const

 template <class _Tp, class _Compare, class _Allocator>
 typename __tree<_Tp, _Compare, _Allocator>::__node_holder
-__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
+__tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p)
 {
    __node_pointer __np = const_cast<__node_pointer>(__p.__ptr_);
    if (__begin_node() == __np)
@@ -2276,16 +2221,6 @@ __tree<_Tp, _Compare, _Allocator>::remove(const_iterator __p) _NOEXCEPT
    return __node_holder(__np, _D(__node_alloc()));
 }

-template <class _Tp, class _Compare, class _Allocator>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-swap(__tree<_Tp, _Compare, _Allocator>& __x,
-     __tree<_Tp, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
-{
-    __x.swap(__y);
-}
-
 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP___TREE
--- a/include/__tuple
+++ b/include/__tuple
@@ -78,39 +78,39 @@ template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : tru

 template <size_t _Ip, class ..._Tp>
 typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(tuple<_Tp...>&) _NOEXCEPT;
+get(tuple<_Tp...>&);

 template <size_t _Ip, class ..._Tp>
 const typename tuple_element<_Ip, tuple<_Tp...> >::type&
-get(const tuple<_Tp...>&) _NOEXCEPT;
+get(const tuple<_Tp...>&);

 template <size_t _Ip, class ..._Tp>
 typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&&) _NOEXCEPT;
+get(tuple<_Tp...>&&);

 template <size_t _Ip, class _T1, class _T2>
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(pair<_T1, _T2>&) _NOEXCEPT;
+get(pair<_T1, _T2>&);

 template <size_t _Ip, class _T1, class _T2>
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(const pair<_T1, _T2>&) _NOEXCEPT;
+get(const pair<_T1, _T2>&);

 template <size_t _Ip, class _T1, class _T2>
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(pair<_T1, _T2>&&) _NOEXCEPT;
+get(pair<_T1, _T2>&&);

 template <size_t _Ip, class _Tp, size_t _Size>
 _Tp&
-get(array<_Tp, _Size>&) _NOEXCEPT;
+get(array<_Tp, _Size>&);

 template <size_t _Ip, class _Tp, size_t _Size>
 const _Tp&
-get(const array<_Tp, _Size>&) _NOEXCEPT;
+get(const array<_Tp, _Size>&);

 template <size_t _Ip, class _Tp, size_t _Size>
 _Tp&&
-get(array<_Tp, _Size>&&) _NOEXCEPT;
+get(array<_Tp, _Size>&&);

 // __make_tuple_indices

@@ -214,7 +214,11 @@ 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 <>
--- a/include/algorithm
+++ b/include/algorithm
--- a/include/array
+++ b/include/array
@@ -34,28 +34,28 @@ struct array

    // No explicit construct/copy/destroy for aggregate type
    void fill(const T& u);
-    void swap(array& a) noexcept(noexcept(swap(declval<T&>(), declval<T&>())));
+    void swap(array& a);

    // iterators:
-    iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator end() noexcept;
-    const_iterator end() const noexcept;
+    iterator begin();
+    const_iterator begin() const;
+    iterator end();
+    const_iterator end() const;

-    reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-    reverse_iterator rend() noexcept;
-    const_reverse_iterator rend() const noexcept;
+    reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+    reverse_iterator rend();
+    const_reverse_iterator rend() const;

-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend() const noexcept;
+    const_iterator cbegin() const;
+    const_iterator cend() const;
+    const_reverse_iterator crbegin() const;
+    const_reverse_iterator crend() const;

    // capacity:
-    constexpr size_type size() const noexcept;
-    constexpr size_type max_size() const noexcept;
-    bool empty() const noexcept;
+    constexpr size_type size() const;
+    constexpr size_type max_size() const;
+    bool empty() const;

    // element access:
    reference operator[](size_type n);
@@ -68,8 +68,8 @@ struct array
    reference back();
    const_reference back() const;

-    T* data() noexcept;
-    const T* data() const noexcept;
+    T* data();
+    const T* data() const;
 };

 template <class T, size_t N>
@@ -86,15 +86,15 @@ template <class T, size_t N>
  bool operator>=(const array<T,N>& x, const array<T,N>& y);

 template <class T, size_t N >
-  void swap(array<T,N>& x, array<T,N>& y) noexcept(noexcept(x.swap(y)));
+  void swap(array<T,N>& x, array<T,N>& y);

 template <class T> class tuple_size;
 template <int I, class T> class tuple_element;
 template <class T, size_t N> struct tuple_size<array<T, N>>;
 template <int I, class T, size_t N> struct tuple_element<I, array<T, N>>;
-template <int I, class T, size_t N> T& get(array<T, N>&) noexcept;
-template <int I, class T, size_t N> const T& get(const array<T, N>&) noexcept;
-template <int I, class T, size_t N> T&& get(array<T, N>&&) noexcept;
+template <int I, class T, size_t N> T& get(array<T, N>&);
+template <int I, class T, size_t N> const T& get(const array<T, N>&);
+template <int I, class T, size_t N> T&& get(array<T, N>&&);

 }  // std

@@ -136,46 +136,30 @@ struct _LIBCPP_VISIBLE array

    // No explicit construct/copy/destroy for aggregate type
    _LIBCPP_INLINE_VISIBILITY void fill(const value_type& __u)
-        {_VSTD::fill_n(__elems_, _Size, __u);}
-    _LIBCPP_INLINE_VISIBILITY
-    void swap(array& __a) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
-        {_VSTD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}
+        {_STD::fill_n(__elems_, _Size, __u);}
+    _LIBCPP_INLINE_VISIBILITY void swap(array& __a)
+        {_STD::swap_ranges(__elems_, __elems_ + _Size, __a.__elems_);}

    // iterators:
-    _LIBCPP_INLINE_VISIBILITY
-    iterator begin() _NOEXCEPT {return iterator(__elems_);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return const_iterator(__elems_);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator end() _NOEXCEPT {return iterator(__elems_ + _Size);}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT {return const_iterator(__elems_ + _Size);}
+    _LIBCPP_INLINE_VISIBILITY iterator begin()             {return iterator(__elems_);}
+    _LIBCPP_INLINE_VISIBILITY const_iterator begin() const {return const_iterator(__elems_);}
+    _LIBCPP_INLINE_VISIBILITY iterator end()               {return iterator(__elems_ + _Size);}
+    _LIBCPP_INLINE_VISIBILITY const_iterator end() const   {return const_iterator(__elems_ + _Size);}

-    _LIBCPP_INLINE_VISIBILITY
-    reverse_iterator rbegin() _NOEXCEPT {return reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT {return const_reverse_iterator(end());}
-    _LIBCPP_INLINE_VISIBILITY
-    reverse_iterator rend() _NOEXCEPT {return reverse_iterator(begin());}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT {return const_reverse_iterator(begin());}
+    _LIBCPP_INLINE_VISIBILITY reverse_iterator rbegin()             {return reverse_iterator(end());}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
+    _LIBCPP_INLINE_VISIBILITY reverse_iterator rend()               {return reverse_iterator(begin());}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rend() const   {return const_reverse_iterator(begin());}

-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return begin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
-    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+    _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const          {return begin();}
+    _LIBCPP_INLINE_VISIBILITY const_iterator cend() const            {return end();}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crbegin() const {return rbegin();}
+    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator crend() const   {return rend();}

    // capacity:
-    _LIBCPP_INLINE_VISIBILITY
-    /*constexpr*/ size_type size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY
-    /*constexpr*/ size_type max_size() const _NOEXCEPT {return _Size;}
-    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return _Size == 0;}
+    _LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type size() const      {return _Size;}
+    _LIBCPP_INLINE_VISIBILITY /*constexpr*/ size_type max_size() const  {return _Size;}
+    _LIBCPP_INLINE_VISIBILITY bool empty() const                    {return _Size == 0;}

    // element access:
    _LIBCPP_INLINE_VISIBILITY reference operator[](size_type __n)             {return __elems_[__n];}
@@ -188,10 +172,8 @@ struct _LIBCPP_VISIBLE array
    _LIBCPP_INLINE_VISIBILITY reference back()              {return __elems_[_Size > 0 ? _Size-1 : 0];}
    _LIBCPP_INLINE_VISIBILITY const_reference back() const  {return __elems_[_Size > 0 ? _Size-1 : 0];}

-    _LIBCPP_INLINE_VISIBILITY
-    value_type* data() _NOEXCEPT {return __elems_;}
-    _LIBCPP_INLINE_VISIBILITY
-    const value_type* data() const _NOEXCEPT {return __elems_;}
+    _LIBCPP_INLINE_VISIBILITY value_type* data()             {return __elems_;}
+    _LIBCPP_INLINE_VISIBILITY const value_type* data() const {return __elems_;}
 };

 template <class _Tp, size_t _Size>
@@ -225,7 +207,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator==(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
-    return _VSTD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
+    return _STD::equal(__x.__elems_, __x.__elems_ + _Size, __y.__elems_);
 }

 template <class _Tp, size_t _Size>
@@ -241,7 +223,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 bool
 operator<(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
 {
-    return _VSTD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
+    return _STD::lexicographical_compare(__x.__elems_, __x.__elems_ + _Size, __y.__elems_, __y.__elems_ + _Size);
 }

 template <class _Tp, size_t _Size>
@@ -270,13 +252,8 @@ operator>=(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)

 template <class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY inline
-typename enable_if
-<
-    __is_swappable<_Tp>::value,
-    void
->::type
+void
 swap(const array<_Tp, _Size>& __x, const array<_Tp, _Size>& __y)
-                                  _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
 {
    __x.swap(__y);
 }
@@ -306,7 +283,7 @@ public:
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY inline
 _Tp&
-get(array<_Tp, _Size>& __a) _NOEXCEPT
+get(array<_Tp, _Size>& __a)
 {
    return __a[_Ip];
 }
@@ -314,7 +291,7 @@ get(array<_Tp, _Size>& __a) _NOEXCEPT
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY inline
 const _Tp&
-get(const array<_Tp, _Size>& __a) _NOEXCEPT
+get(const array<_Tp, _Size>& __a)
 {
    return __a[_Ip];
 }
@@ -324,9 +301,9 @@ get(const array<_Tp, _Size>& __a) _NOEXCEPT
 template <size_t _Ip, class _Tp, size_t _Size>
 _LIBCPP_INLINE_VISIBILITY inline
 _Tp&&
-get(array<_Tp, _Size>&& __a) _NOEXCEPT
+get(array<_Tp, _Size>&& __a)
 {
-    return _VSTD::move(__a[_Ip]);
+    return _STD::move(__a[_Ip]);
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
--- a/include/bitset
+++ b/include/bitset
@@ -27,19 +27,19 @@ public:
    class reference
    {
        friend class bitset;
-        reference() noexcept;
+        reference();
    public:
-        ~reference() noexcept;
-        reference& operator=(bool x) noexcept;           // for b[i] = x;
-        reference& operator=(const reference&) noexcept; // for b[i] = b[j];
-        bool operator~() const noexcept;                 // flips the bit
-        operator bool() const noexcept;                  // for x = b[i];
-        reference& flip() noexcept;                      // for b[i].flip();
+        ~reference();
+        reference& operator=(bool x);           // for b[i] = x;
+        reference& operator=(const reference&); // for b[i] = b[j];
+        bool operator~() const;                 // flips the bit
+        operator bool() const;                  // for x = b[i];
+        reference& flip();                      // for b[i].flip();
    };

    // 23.3.5.1 constructors:
-    constexpr bitset() noexcept;
-    constexpr bitset(unsigned long long val) noexcept;
+    constexpr bitset();
+    constexpr bitset(unsigned long long val);
    template <class charT>
        explicit bitset(const charT* str,
                        typename basic_string<charT>::size_type n = basic_string<charT>::npos,
@@ -52,17 +52,17 @@ public:
                        charT zero = charT('0'), charT one = charT('1'));

    // 23.3.5.2 bitset operations:
-    bitset& operator&=(const bitset& rhs) noexcept;
-    bitset& operator|=(const bitset& rhs) noexcept;
-    bitset& operator^=(const bitset& rhs) noexcept;
-    bitset& operator<<=(size_t pos) noexcept;
-    bitset& operator>>=(size_t pos) noexcept;
-    bitset& set() noexcept;
+    bitset& operator&=(const bitset& rhs);
+    bitset& operator|=(const bitset& rhs);
+    bitset& operator^=(const bitset& rhs);
+    bitset& operator<<=(size_t pos);
+    bitset& operator>>=(size_t pos);
+    bitset& set();
    bitset& set(size_t pos, bool val = true);
-    bitset& reset() noexcept;
+    bitset& reset();
    bitset& reset(size_t pos);
-    bitset operator~() const noexcept;
-    bitset& flip() noexcept;
+    bitset operator~() const;
+    bitset& flip();
    bitset& flip(size_t pos);

    // element access:
@@ -77,27 +77,27 @@ public:
    template <class charT>
        basic_string<charT, char_traits<charT>, allocator<charT> > to_string(charT zero = charT('0'), charT one = charT('1')) const;
    basic_string<char, char_traits<char>, allocator<char> > to_string(char zero = '0', char one = '1') const;
-    size_t count() const noexcept;
-    constexpr size_t size() const noexcept;
-    bool operator==(const bitset& rhs) const noexcept;
-    bool operator!=(const bitset& rhs) const noexcept;
+    size_t count() const;
+    constexpr size_t size() const;
+    bool operator==(const bitset& rhs) const;
+    bool operator!=(const bitset& rhs) const;
    bool test(size_t pos) const;
-    bool all() const noexcept;
-    bool any() const noexcept;
-    bool none() const noexcept;
-    bitset operator<<(size_t pos) const noexcept;
-    bitset operator>>(size_t pos) const noexcept;
+    bool all() const;
+    bool any() const;
+    bool none() const;
+    bitset operator<<(size_t pos) const;
+    bitset operator>>(size_t pos) const;
 };

 // 23.3.5.3 bitset operators:
 template <size_t N>
-bitset<N> operator&(const bitset<N>&, const bitset<N>&) noexcept;
+bitset<N> operator&(const bitset<N>&, const bitset<N>&);

 template <size_t N>
-bitset<N> operator|(const bitset<N>&, const bitset<N>&) noexcept;
+bitset<N> operator|(const bitset<N>&, const bitset<N>&);

 template <size_t N>
-bitset<N> operator^(const bitset<N>&, const bitset<N>&) noexcept;
+bitset<N> operator^(const bitset<N>&, const bitset<N>&);

 template <class charT, class traits, size_t N>
 basic_istream<charT, traits>&
@@ -129,15 +129,6 @@ 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
 {
@@ -164,34 +155,34 @@ protected:
    typedef __bit_iterator<__bitset, false>            iterator;
    typedef __bit_iterator<__bitset, true>             const_iterator;

-    __bitset() _NOEXCEPT;
-    explicit __bitset(unsigned long long __v) _NOEXCEPT;
+    __bitset();
+    explicit __bitset(unsigned long long __v);

-    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos)
        {return reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const
        {return const_reference(__first_ + __pos / __bits_per_word, __storage_type(1) << __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos)
        {return iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const
        {return const_iterator(__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}

-    void operator&=(const __bitset& __v) _NOEXCEPT;
-    void operator|=(const __bitset& __v) _NOEXCEPT;
-    void operator^=(const __bitset& __v) _NOEXCEPT;
+    void operator&=(const __bitset& __v);
+    void operator|=(const __bitset& __v);
+    void operator^=(const __bitset& __v);

-    void flip() _NOEXCEPT;
+    void flip();
    _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const
        {return to_ulong(integral_constant<bool, _Size < sizeof(unsigned long) * CHAR_BIT>());}
    _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const
        {return to_ullong(integral_constant<bool, _Size < sizeof(unsigned long long) * CHAR_BIT>());}

-    bool all() const _NOEXCEPT;
-    bool any() const _NOEXCEPT;
-    size_t __hash_code() const _NOEXCEPT;
+    bool all() const;
+    bool any() const;
+    size_t __hash_code() const;
 private:
-    void __init(unsigned long long __v, false_type) _NOEXCEPT;
-    void __init(unsigned long long __v, true_type) _NOEXCEPT;
+    void __init(unsigned long long __v, false_type);
+    void __init(unsigned long long __v, true_type);
    unsigned long to_ulong(false_type) const;
    unsigned long to_ulong(true_type) const;
    unsigned long long to_ullong(false_type) const;
@@ -202,9 +193,9 @@ private:

 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<_N_words, _Size>::__bitset() _NOEXCEPT
+__bitset<_N_words, _Size>::__bitset()
 {
-    _VSTD::fill_n(__first_, _N_words, __storage_type(0));
+    _STD::fill_n(__first_, _N_words, __storage_type(0));
 }

 template <size_t _N_words, size_t _Size>
@@ -214,8 +205,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);
-    _VSTD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
-    _VSTD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
+    _STD::copy(__t, __t + sizeof(__t)/sizeof(__t[0]), __first_);
+    _STD::fill(__first_ + sizeof(__t)/sizeof(__t[0]), __first_ + sizeof(__first_)/sizeof(__first_[0]),
               __storage_type(0));
 }

@@ -225,12 +216,12 @@ void
 __bitset<_N_words, _Size>::__init(unsigned long long __v, true_type)
 {
    __first_[0] = __v;
-    _VSTD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
+    _STD::fill(__first_ + 1, __first_ + sizeof(__first_)/sizeof(__first_[0]), __storage_type(0));
 }

 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
+__bitset<_N_words, _Size>::__bitset(unsigned long long __v)
 {
    __init(__v, integral_constant<bool, sizeof(unsigned long long) == sizeof(__storage_type)>());
 }
@@ -238,7 +229,7 @@ __bitset<_N_words, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
+__bitset<_N_words, _Size>::operator&=(const __bitset& __v)
 {
    for (size_type __i = 0; __i < _N_words; ++__i)
        __first_[__i] &= __v.__first_[__i];
@@ -247,7 +238,7 @@ __bitset<_N_words, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
+__bitset<_N_words, _Size>::operator|=(const __bitset& __v)
 {
    for (size_type __i = 0; __i < _N_words; ++__i)
        __first_[__i] |= __v.__first_[__i];
@@ -256,7 +247,7 @@ __bitset<_N_words, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
+__bitset<_N_words, _Size>::operator^=(const __bitset& __v)
 {
    for (size_type __i = 0; __i < _N_words; ++__i)
        __first_[__i] ^= __v.__first_[__i];
@@ -264,7 +255,7 @@ __bitset<_N_words, _Size>::operator^=(const __bitset& __v) _NOEXCEPT

 template <size_t _N_words, size_t _Size>
 void
-__bitset<_N_words, _Size>::flip() _NOEXCEPT
+__bitset<_N_words, _Size>::flip()
 {
    // do middle whole words
    size_type __n = _Size;
@@ -286,7 +277,7 @@ unsigned long
 __bitset<_N_words, _Size>::to_ulong(false_type) const
 {
    const_iterator __e = __make_iter(_Size);
-    const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long) * CHAR_BIT), __e, true);
+    const_iterator __i = _STD::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");
@@ -309,7 +300,7 @@ unsigned long long
 __bitset<_N_words, _Size>::to_ullong(false_type) const
 {
    const_iterator __e = __make_iter(_Size);
-    const_iterator __i = _VSTD::find(__make_iter(sizeof(unsigned long long) * CHAR_BIT), __e, true);
+    const_iterator __i = _STD::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");
@@ -347,7 +338,7 @@ __bitset<_N_words, _Size>::to_ullong(true_type, true_type) const

 template <size_t _N_words, size_t _Size>
 bool
-__bitset<_N_words, _Size>::all() const _NOEXCEPT
+__bitset<_N_words, _Size>::all() const
 {
    // do middle whole words
    size_type __n = _Size;
@@ -367,7 +358,7 @@ __bitset<_N_words, _Size>::all() const _NOEXCEPT

 template <size_t _N_words, size_t _Size>
 bool
-__bitset<_N_words, _Size>::any() const _NOEXCEPT
+__bitset<_N_words, _Size>::any() const
 {
    // do middle whole words
    size_type __n = _Size;
@@ -388,7 +379,7 @@ __bitset<_N_words, _Size>::any() const _NOEXCEPT
 template <size_t _N_words, size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 size_t
-__bitset<_N_words, _Size>::__hash_code() const _NOEXCEPT
+__bitset<_N_words, _Size>::__hash_code() const
 {
    size_t __h = 0;
    for (size_type __i = 0; __i < _N_words; ++__i)
@@ -422,43 +413,43 @@ protected:
    typedef __bit_iterator<__bitset, false>            iterator;
    typedef __bit_iterator<__bitset, true>             const_iterator;

-    __bitset() _NOEXCEPT;
-    explicit __bitset(unsigned long long __v) _NOEXCEPT;
+    __bitset();
+    explicit __bitset(unsigned long long __v);

-    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t __pos)
        {return reference(&__first_, __storage_type(1) << __pos);}
-    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t __pos) const
        {return const_reference(&__first_, __storage_type(1) << __pos);}
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos)
        {return iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const
        {return const_iterator(&__first_ + __pos / __bits_per_word, __pos % __bits_per_word);}

-    void operator&=(const __bitset& __v) _NOEXCEPT;
-    void operator|=(const __bitset& __v) _NOEXCEPT;
-    void operator^=(const __bitset& __v) _NOEXCEPT;
+    void operator&=(const __bitset& __v);
+    void operator|=(const __bitset& __v);
+    void operator^=(const __bitset& __v);

-    void flip() _NOEXCEPT;
+    void flip();

    unsigned long to_ulong() const;
    unsigned long long to_ullong() const;

-    bool all() const _NOEXCEPT;
-    bool any() const _NOEXCEPT;
+    bool all() const;
+    bool any() const;

-    size_t __hash_code() const _NOEXCEPT;
+    size_t __hash_code() const;
 };

 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<1, _Size>::__bitset() _NOEXCEPT
+__bitset<1, _Size>::__bitset()
    : __first_(0)
 {
 }

 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
+__bitset<1, _Size>::__bitset(unsigned long long __v)
    : __first_(static_cast<__storage_type>(__v))
 {
 }
@@ -466,7 +457,7 @@ __bitset<1, _Size>::__bitset(unsigned long long __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
+__bitset<1, _Size>::operator&=(const __bitset& __v)
 {
    __first_ &= __v.__first_;
 }
@@ -474,7 +465,7 @@ __bitset<1, _Size>::operator&=(const __bitset& __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
+__bitset<1, _Size>::operator|=(const __bitset& __v)
 {
    __first_ |= __v.__first_;
 }
@@ -482,7 +473,7 @@ __bitset<1, _Size>::operator|=(const __bitset& __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
+__bitset<1, _Size>::operator^=(const __bitset& __v)
 {
    __first_ ^= __v.__first_;
 }
@@ -490,7 +481,7 @@ __bitset<1, _Size>::operator^=(const __bitset& __v) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-__bitset<1, _Size>::flip() _NOEXCEPT
+__bitset<1, _Size>::flip()
 {
    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
    __first_ = ~__first_;
@@ -516,7 +507,7 @@ __bitset<1, _Size>::to_ullong() const
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-__bitset<1, _Size>::all() const _NOEXCEPT
+__bitset<1, _Size>::all() const
 {
    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
    return !(~__first_ & __m);
@@ -525,7 +516,7 @@ __bitset<1, _Size>::all() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-__bitset<1, _Size>::any() const _NOEXCEPT
+__bitset<1, _Size>::any() const
 {
    __storage_type __m = ~__storage_type(0) >> (__bits_per_word - _Size);
    return __first_ & __m;
@@ -534,7 +525,7 @@ __bitset<1, _Size>::any() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 size_t
-__bitset<1, _Size>::__hash_code() const _NOEXCEPT
+__bitset<1, _Size>::__hash_code() const
 {
    return __first_;
 }
@@ -563,40 +554,40 @@ protected:
    typedef __bit_iterator<__bitset, false>            iterator;
    typedef __bit_iterator<__bitset, true>             const_iterator;

-    __bitset() _NOEXCEPT;
-    explicit __bitset(unsigned long long) _NOEXCEPT;
+    __bitset();
+    explicit __bitset(unsigned long long);

-    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY reference __make_ref(size_t)
        {return reference(0, 1);}
-    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_reference __make_ref(size_t) const
        {return const_reference(0, 1);}
-    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos) _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY iterator __make_iter(size_t __pos)
        {return iterator(0, 0);}
-    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const _NOEXCEPT
+    _LIBCPP_INLINE_VISIBILITY const_iterator __make_iter(size_t __pos) const
        {return const_iterator(0, 0);}

-    _LIBCPP_INLINE_VISIBILITY void operator&=(const __bitset&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY void operator|=(const __bitset&) _NOEXCEPT {}
-    _LIBCPP_INLINE_VISIBILITY void operator^=(const __bitset&) _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY void operator&=(const __bitset&) {}
+    _LIBCPP_INLINE_VISIBILITY void operator|=(const __bitset&) {}
+    _LIBCPP_INLINE_VISIBILITY void operator^=(const __bitset&) {}

-    _LIBCPP_INLINE_VISIBILITY void flip() _NOEXCEPT {}
+    _LIBCPP_INLINE_VISIBILITY void flip() {}

    _LIBCPP_INLINE_VISIBILITY unsigned long to_ulong() const {return 0;}
    _LIBCPP_INLINE_VISIBILITY unsigned long long to_ullong() const {return 0;}

-    _LIBCPP_INLINE_VISIBILITY bool all() const _NOEXCEPT {return true;}
-    _LIBCPP_INLINE_VISIBILITY bool any() const _NOEXCEPT {return false;}
+    _LIBCPP_INLINE_VISIBILITY bool all() const {return true;}
+    _LIBCPP_INLINE_VISIBILITY bool any() const {return false;}

-    _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const _NOEXCEPT {return 0;}
+    _LIBCPP_INLINE_VISIBILITY size_t __hash_code() const {return 0;}
 };

 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<0, 0>::__bitset() _NOEXCEPT
+__bitset<0, 0>::__bitset()
 {
 }

 inline _LIBCPP_INLINE_VISIBILITY
-__bitset<0, 0>::__bitset(unsigned long long) _NOEXCEPT
+__bitset<0, 0>::__bitset(unsigned long long)
 {
 }

@@ -615,8 +606,8 @@ public:
    typedef typename base::const_reference const_reference;

    // 23.3.5.1 constructors:
-    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset() _NOEXCEPT {}
-    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset(unsigned long long __v) _NOEXCEPT : base(__v) {}
+    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset() {}
+    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY bitset(unsigned long long __v) : base(__v) {}
    template<class _CharT>
        explicit bitset(const _CharT* __str,
                        typename basic_string<_CharT>::size_type __n = basic_string<_CharT>::npos,
@@ -629,17 +620,17 @@ public:
                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));

    // 23.3.5.2 bitset operations:
-    bitset& operator&=(const bitset& __rhs) _NOEXCEPT;
-    bitset& operator|=(const bitset& __rhs) _NOEXCEPT;
-    bitset& operator^=(const bitset& __rhs) _NOEXCEPT;
-    bitset& operator<<=(size_t __pos) _NOEXCEPT;
-    bitset& operator>>=(size_t __pos) _NOEXCEPT;
-    bitset& set() _NOEXCEPT;
+    bitset& operator&=(const bitset& __rhs);
+    bitset& operator|=(const bitset& __rhs);
+    bitset& operator^=(const bitset& __rhs);
+    bitset& operator<<=(size_t __pos);
+    bitset& operator>>=(size_t __pos);
+    bitset& set();
    bitset& set(size_t __pos, bool __val = true);
-    bitset& reset() _NOEXCEPT;
+    bitset& reset();
    bitset& reset(size_t __pos);
-    bitset  operator~() const _NOEXCEPT;
-    bitset& flip() _NOEXCEPT;
+    bitset  operator~() const;
+    bitset& flip();
    bitset& flip(size_t __pos);

    // element access:
@@ -658,21 +649,21 @@ public:
                                                                                _CharT __one = _CharT('1')) const;
    basic_string<char, char_traits<char>, allocator<char> > to_string(char __zero = '0',
                                                                      char __one = '1') const;
-    size_t count() const _NOEXCEPT;
-    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY size_t size() const _NOEXCEPT {return _Size;}
-    bool operator==(const bitset& __rhs) const _NOEXCEPT;
-    bool operator!=(const bitset& __rhs) const _NOEXCEPT;
+    size_t count() const;
+    /*constexpr*/ _LIBCPP_INLINE_VISIBILITY size_t size() const {return _Size;}
+    bool operator==(const bitset& __rhs) const;
+    bool operator!=(const bitset& __rhs) const;
    bool test(size_t __pos) const;
-    bool all() const _NOEXCEPT;
-    bool any() const _NOEXCEPT;
-    _LIBCPP_INLINE_VISIBILITY bool none() const _NOEXCEPT {return !any();}
-    bitset operator<<(size_t __pos) const _NOEXCEPT;
-    bitset operator>>(size_t __pos) const _NOEXCEPT;
+    bool all() const;
+    bool any() const;
+    _LIBCPP_INLINE_VISIBILITY bool none() const {return !any();}
+    bitset operator<<(size_t __pos) const;
+    bitset operator>>(size_t __pos) const;

 private:

    _LIBCPP_INLINE_VISIBILITY
-    size_t __hash_code() const _NOEXCEPT {return base::__hash_code();}
+    size_t __hash_code() const {return base::__hash_code();}

    friend struct hash<bitset>;
 };
@@ -683,7 +674,7 @@ bitset<_Size>::bitset(const _CharT* __str,
                      typename basic_string<_CharT>::size_type __n,
                      _CharT __zero, _CharT __one)
 {
-    size_t __rlen = _VSTD::min(__n, char_traits<_CharT>::length(__str));
+    size_t __rlen = _STD::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
@@ -691,7 +682,7 @@ bitset<_Size>::bitset(const _CharT* __str,
 #else
            assert(!"bitset string ctor has invalid argument");
 #endif
-    size_t _M = _VSTD::min(__rlen, _Size);
+    size_t _M = _STD::min(__rlen, _Size);
    size_t __i = 0;
    for (; __i < _M; ++__i)
    {
@@ -701,7 +692,7 @@ bitset<_Size>::bitset(const _CharT* __str,
        else
            (*this)[__i] = true;
    }
-    _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+    _STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }

 template <size_t _Size>
@@ -717,7 +708,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
 #else
        assert(!"bitset string pos out of range");
 #endif
-    size_t __rlen = _VSTD::min(__n, __str.size() - __pos);
+    size_t __rlen = _STD::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
@@ -725,7 +716,7 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
 #else
            assert(!"bitset string ctor has invalid argument");
 #endif
-    size_t _M = _VSTD::min(__rlen, _Size);
+    size_t _M = _STD::min(__rlen, _Size);
    size_t __i = 0;
    for (; __i < _M; ++__i)
    {
@@ -735,13 +726,13 @@ bitset<_Size>::bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
        else
            (*this)[__i] = true;
    }
-    _VSTD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
+    _STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }

 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
+bitset<_Size>::operator&=(const bitset& __rhs)
 {
    base::operator&=(__rhs);
    return *this;
@@ -750,7 +741,7 @@ bitset<_Size>::operator&=(const bitset& __rhs) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
+bitset<_Size>::operator|=(const bitset& __rhs)
 {
    base::operator|=(__rhs);
    return *this;
@@ -759,7 +750,7 @@ bitset<_Size>::operator|=(const bitset& __rhs) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT
+bitset<_Size>::operator^=(const bitset& __rhs)
 {
    base::operator^=(__rhs);
    return *this;
@@ -767,30 +758,30 @@ bitset<_Size>::operator^=(const bitset& __rhs) _NOEXCEPT

 template <size_t _Size>
 bitset<_Size>&
-bitset<_Size>::operator<<=(size_t __pos) _NOEXCEPT
+bitset<_Size>::operator<<=(size_t __pos)
 {
-    __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);
+    __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);
    return *this;
 }

 template <size_t _Size>
 bitset<_Size>&
-bitset<_Size>::operator>>=(size_t __pos) _NOEXCEPT
+bitset<_Size>::operator>>=(size_t __pos)
 {
-    __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);
+    __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);
    return *this;
 }

 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::set() _NOEXCEPT
+bitset<_Size>::set()
 {
-    _VSTD::fill_n(base::__make_iter(0), _Size, true);
+    _STD::fill_n(base::__make_iter(0), _Size, true);
    return *this;
 }

@@ -811,9 +802,9 @@ bitset<_Size>::set(size_t __pos, bool __val)
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::reset() _NOEXCEPT
+bitset<_Size>::reset()
 {
-    _VSTD::fill_n(base::__make_iter(0), _Size, false);
+    _STD::fill_n(base::__make_iter(0), _Size, false);
    return *this;
 }

@@ -834,7 +825,7 @@ bitset<_Size>::reset(size_t __pos)
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-bitset<_Size>::operator~() const _NOEXCEPT
+bitset<_Size>::operator~() const
 {
    bitset __x(*this);
    __x.flip();
@@ -844,7 +835,7 @@ bitset<_Size>::operator~() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>&
-bitset<_Size>::flip() _NOEXCEPT
+bitset<_Size>::flip()
 {
    base::flip();
    return *this;
@@ -924,23 +915,23 @@ bitset<_Size>::to_string(char __zero, char __one) const
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 size_t
-bitset<_Size>::count() const _NOEXCEPT
+bitset<_Size>::count() const
 {
-    return static_cast<size_t>(_VSTD::count(base::__make_iter(0), base::__make_iter(_Size), true));
+    return static_cast<size_t>(_STD::count(base::__make_iter(0), base::__make_iter(_Size), true));
 }

 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::operator==(const bitset& __rhs) const _NOEXCEPT
+bitset<_Size>::operator==(const bitset& __rhs) const
 {
-    return _VSTD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
+    return _STD::equal(base::__make_iter(0), base::__make_iter(_Size), __rhs.__make_iter(0));
 }

 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::operator!=(const bitset& __rhs) const _NOEXCEPT
+bitset<_Size>::operator!=(const bitset& __rhs) const
 {
    return !(*this == __rhs);
 }
@@ -961,7 +952,7 @@ bitset<_Size>::test(size_t __pos) const
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::all() const _NOEXCEPT
+bitset<_Size>::all() const
 {
    return base::all();
 }
@@ -969,7 +960,7 @@ bitset<_Size>::all() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-bitset<_Size>::any() const _NOEXCEPT
+bitset<_Size>::any() const
 {
    return base::any();
 }
@@ -977,7 +968,7 @@ bitset<_Size>::any() const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
+bitset<_Size>::operator<<(size_t __pos) const
 {
    bitset __r = *this;
    __r <<= __pos;
@@ -987,7 +978,7 @@ bitset<_Size>::operator<<(size_t __pos) const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
+bitset<_Size>::operator>>(size_t __pos) const
 {
    bitset __r = *this;
    __r >>= __pos;
@@ -997,7 +988,7 @@ bitset<_Size>::operator>>(size_t __pos) const _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
+operator&(const bitset<_Size>& __x, const bitset<_Size>& __y)
 {
    bitset<_Size> __r = __x;
    __r &= __y;
@@ -1007,7 +998,7 @@ operator&(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
+operator|(const bitset<_Size>& __x, const bitset<_Size>& __y)
 {
    bitset<_Size> __r = __x;
    __r |= __y;
@@ -1017,7 +1008,7 @@ operator|(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
 template <size_t _Size>
 inline _LIBCPP_INLINE_VISIBILITY
 bitset<_Size>
-operator^(const bitset<_Size>& __x, const bitset<_Size>& __y) _NOEXCEPT
+operator^(const bitset<_Size>& __x, const bitset<_Size>& __y)
 {
    bitset<_Size> __r = __x;
    __r ^= __y;
@@ -1029,18 +1020,10 @@ struct _LIBCPP_VISIBLE hash<bitset<_Size> >
    : public unary_function<bitset<_Size>, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const bitset<_Size>& __bs) const _NOEXCEPT
+    size_t operator()(const bitset<_Size>& __bs) const
        {return __bs.__hash_code();}
 };

-template <class _CharT, class _Traits, size_t _Size>
-basic_istream<_CharT, _Traits>&
-operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x);
-
-template <class _CharT, class _Traits, size_t _Size>
-basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x);
-
 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP_BITSET
--- a/include/cerrno
+++ b/include/cerrno
@@ -72,320 +72,4 @@ const int __elast2 = 105;

 #endif  // !defined(EOWNERDEAD) || !defined(ENOTRECOVERABLE)

-//  supply errno values likely to be missing, particularly on Windows
-
-#ifndef EAFNOSUPPORT
-#define EAFNOSUPPORT 9901
-#endif
-
-#ifndef EADDRINUSE
-#define EADDRINUSE 9902
-#endif
-
-#ifndef EADDRNOTAVAIL
-#define EADDRNOTAVAIL 9903
-#endif
-
-#ifndef EISCONN
-#define EISCONN 9904
-#endif
-
-#ifndef EBADMSG
-#define EBADMSG 9905
-#endif
-
-#ifndef ECONNABORTED
-#define ECONNABORTED 9906
-#endif
-
-#ifndef EALREADY
-#define EALREADY 9907
-#endif
-
-#ifndef ECONNREFUSED
-#define ECONNREFUSED 9908
-#endif
-
-#ifndef ECONNRESET
-#define ECONNRESET 9909
-#endif
-
-#ifndef EDESTADDRREQ
-#define EDESTADDRREQ 9910
-#endif
-
-#ifndef EHOSTUNREACH
-#define EHOSTUNREACH 9911
-#endif
-
-#ifndef EIDRM
-#define EIDRM 9912
-#endif
-
-#ifndef EMSGSIZE
-#define EMSGSIZE 9913
-#endif
-
-#ifndef ENETDOWN
-#define ENETDOWN 9914
-#endif
-
-#ifndef ENETRESET
-#define ENETRESET 9915
-#endif
-
-#ifndef ENETUNREACH
-#define ENETUNREACH 9916
-#endif
-
-#ifndef ENOBUFS
-#define ENOBUFS 9917
-#endif
-
-#ifndef ENOLINK
-#define ENOLINK 9918
-#endif
-
-#ifndef ENODATA
-#define ENODATA 9919
-#endif
-
-#ifndef ENOMSG
-#define ENOMSG 9920
-#endif
-
-#ifndef ENOPROTOOPT
-#define ENOPROTOOPT 9921
-#endif
-
-#ifndef ENOSR
-#define ENOSR 9922
-#endif
-
-#ifndef ENOTSOCK
-#define ENOTSOCK 9923
-#endif
-
-#ifndef ENOSTR
-#define ENOSTR 9924
-#endif
-
-#ifndef ENOTCONN
-#define ENOTCONN 9925
-#endif
-
-#ifndef ENOTSUP
-#define ENOTSUP 9926
-#endif
-
-#ifndef ECANCELED
-#define ECANCELED 9927
-#endif
-
-#ifndef EINPROGRESS
-#define EINPROGRESS 9928
-#endif
-
-#ifndef EOPNOTSUPP
-#define EOPNOTSUPP 9929
-#endif
-
-#ifndef EWOULDBLOCK
-#define EWOULDBLOCK 9930
-#endif
-
-#ifndef EOWNERDEAD
-#define EOWNERDEAD  9931
-#endif
-
-#ifndef EPROTO
-#define EPROTO 9932
-#endif
-
-#ifndef EPROTONOSUPPORT
-#define EPROTONOSUPPORT 9933
-#endif
-
-#ifndef ENOTRECOVERABLE
-#define ENOTRECOVERABLE 9934
-#endif
-
-#ifndef ETIME
-#define ETIME 9935
-#endif
-
-#ifndef ETXTBSY
-#define ETXTBSY 9936
-#endif
-
-#ifndef ETIMEDOUT
-#define ETIMEDOUT 9938
-#endif
-
-#ifndef ELOOP
-#define ELOOP 9939
-#endif
-
-#ifndef EOVERFLOW
-#define EOVERFLOW 9940
-#endif
-
-#ifndef EPROTOTYPE
-#define EPROTOTYPE 9941
-#endif
-
-#ifndef ENOSYS
-#define ENOSYS 9942
-#endif
-
-#ifndef EINVAL
-#define EINVAL 9943
-#endif
-
-#ifndef ERANGE
-#define ERANGE 9944
-#endif
-
-#ifndef EILSEQ
-#define EILSEQ 9945
-#endif
-
-//  Windows Mobile doesn't appear to define these:
-
-#ifndef E2BIG
-#define E2BIG 9946
-#endif
-
-#ifndef EDOM
-#define EDOM 9947
-#endif
-
-#ifndef EFAULT
-#define EFAULT 9948
-#endif
-
-#ifndef EBADF
-#define EBADF 9949
-#endif
-
-#ifndef EPIPE
-#define EPIPE 9950
-#endif
-
-#ifndef EXDEV
-#define EXDEV 9951
-#endif
-
-#ifndef EBUSY
-#define EBUSY 9952
-#endif
-
-#ifndef ENOTEMPTY
-#define ENOTEMPTY 9953
-#endif
-
-#ifndef ENOEXEC
-#define ENOEXEC 9954
-#endif
-
-#ifndef EEXIST
-#define EEXIST 9955
-#endif
-
-#ifndef EFBIG
-#define EFBIG 9956
-#endif
-
-#ifndef ENAMETOOLONG
-#define ENAMETOOLONG 9957
-#endif
-
-#ifndef ENOTTY
-#define ENOTTY 9958
-#endif
-
-#ifndef EINTR
-#define EINTR 9959
-#endif
-
-#ifndef ESPIPE
-#define ESPIPE 9960
-#endif
-
-#ifndef EIO
-#define EIO 9961
-#endif
-
-#ifndef EISDIR
-#define EISDIR 9962
-#endif
-
-#ifndef ECHILD
-#define ECHILD 9963
-#endif
-
-#ifndef ENOLCK
-#define ENOLCK 9964
-#endif
-
-#ifndef ENOSPC
-#define ENOSPC 9965
-#endif
-
-#ifndef ENXIO
-#define ENXIO 9966
-#endif
-
-#ifndef ENODEV
-#define ENODEV 9967
-#endif
-
-#ifndef ENOENT
-#define ENOENT 9968
-#endif
-
-#ifndef ESRCH
-#define ESRCH 9969
-#endif
-
-#ifndef ENOTDIR
-#define ENOTDIR 9970
-#endif
-
-#ifndef ENOMEM
-#define ENOMEM 9971
-#endif
-
-#ifndef EPERM
-#define EPERM 9972
-#endif
-
-#ifndef EACCES
-#define EACCES 9973
-#endif
-
-#ifndef EROFS
-#define EROFS 9974
-#endif
-
-#ifndef EDEADLK
-#define EDEADLK 9975
-#endif
-
-#ifndef EAGAIN
-#define EAGAIN 9976
-#endif
-
-#ifndef ENFILE
-#define ENFILE 9977
-#endif
-
-#ifndef EMFILE
-#define EMFILE 9978
-#endif
-
-#ifndef EMLINK
-#define EMLINK 9979
-#endif
-
 #endif  // _LIBCPP_CERRNO
--- a/include/chrono
+++ b/include/chrono
@@ -225,9 +225,9 @@ public:
    typedef chrono::time_point<system_clock> time_point;
    static const bool is_steady =            false;

-    static time_point now() noexcept;
-    static time_t     to_time_t  (const time_point& __t) noexcept;
-    static time_point from_time_t(time_t __t) noexcept;
+    static time_point now();
+    static time_t     to_time_t  (const time_point& __t);
+    static time_point from_time_t(time_t __t);
 };

 class steady_clock
@@ -239,7 +239,7 @@ public:
    typedef chrono::time_point<steady_clock, duration>    time_point;
    static const bool is_steady =                         true;

-    static time_point now() noexcept;
+    static time_point now();
 };

 typedef steady_clock high_resolution_clock;
@@ -407,7 +407,7 @@ public:
                (ratio_divide<_Period2, period>::type::den == 1 &&
                 !treat_as_floating_point<_Rep2>::value)
            >::type* = 0)
-                : __rep_(_VSTD::chrono::duration_cast<duration>(__d).count()) {}
+                : __rep_(_STD::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>(_VSTD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
+    return time_point<_Clock, _ToDuration>(_STD::chrono::duration_cast<_ToDuration>(__t.time_since_epoch()));
 }

 // time_point ==
@@ -845,9 +845,9 @@ public:
    typedef chrono::time_point<system_clock> time_point;
    static const bool is_steady =            false;

-    static time_point now() _NOEXCEPT;
-    static time_t     to_time_t  (const time_point& __t) _NOEXCEPT;
-    static time_point from_time_t(time_t __t) _NOEXCEPT;
+    static time_point now();
+    static time_t     to_time_t  (const time_point& __t);
+    static time_point from_time_t(time_t __t);
 };

 class _LIBCPP_VISIBLE steady_clock
@@ -859,7 +859,7 @@ public:
    typedef chrono::time_point<steady_clock, duration>    time_point;
    static const bool is_steady =                         true;

-    static time_point now() _NOEXCEPT;
+    static time_point now();
 };

 typedef steady_clock high_resolution_clock;
--- a/include/complex
+++ b/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 _VSTD::pow(result_type(__x), result_type(__y));
+    return _STD::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 _VSTD::pow(result_type(__x), result_type(__y));
+    return _STD::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 _VSTD::pow(result_type(__x), result_type(__y));
+    return _STD::pow(result_type(__x), result_type(__y));
 }

 // asinh
--- a/include/condition_variable
+++ b/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,
-                      _VSTD::move(__pred));
+                      _STD::move(__pred));
 }

 _LIBCPP_VISIBLE
--- a/include/cstddef
+++ b/include/cstddef
@@ -82,19 +82,14 @@ struct _LIBCPP_VISIBLE nullptr_t

 inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}

-#define nullptr _VSTD::__get_nullptr_t()
+#define nullptr _STD::__get_nullptr_t()
+
+#else  // _LIBCPP_HAS_NO_NULLPTR
+
+typedef decltype(nullptr) nullptr_t;

 #endif  // _LIBCPP_HAS_NO_NULLPTR

 _LIBCPP_END_NAMESPACE_STD

-#ifndef _LIBCPP_HAS_NO_NULLPTR
-
-namespace std
-{
-    typedef decltype(nullptr) nullptr_t;
-}
-
-#endif  // _LIBCPP_HAS_NO_NULLPTR
-
 #endif  // _LIBCPP_CSTDDEF
--- a/include/cwchar
+++ b/include/cwchar
@@ -106,9 +106,6 @@ size_t wcsrtombs(char* restrict dst, const wchar_t** restrict src, size_t len,
 #include <__config>
 #include <cwctype>
 #include <wchar.h>
-#if _WIN32
-#include <support/win32/support.h> // pull in *swprintf defines
-#endif // _WIN32

 #pragma GCC system_header

--- a/include/deque
+++ b/include/deque
--- a/include/exception
+++ b/include/exception
@@ -20,56 +20,56 @@ namespace std
 class exception
 {
 public:
-    exception() noexcept;
-    exception(const exception&) noexcept;
-    exception& operator=(const exception&) noexcept;
-    virtual ~exception() noexcept;
-    virtual const char* what() const noexcept;
+    exception() throw();
+    exception(const exception&) throw();
+    exception& operator=(const exception&) throw();
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
 };

 class bad_exception
    : public exception
 {
 public:
-    bad_exception() noexcept;
-    bad_exception(const bad_exception&) noexcept;
-    bad_exception& operator=(const bad_exception&) noexcept;
-    virtual ~bad_exception() noexcept;
-    virtual const char* what() const noexcept;
+    bad_exception() throw();
+    bad_exception(const bad_exception&) throw();
+    bad_exception& operator=(const bad_exception&) throw();
+    virtual ~bad_exception() throw();
+    virtual const char* what() const throw();
 };

 typedef void (*unexpected_handler)();
-unexpected_handler set_unexpected(unexpected_handler  f ) noexcept;
-unexpected_handler get_unexpected() noexcept;
-[[noreturn]] void unexpected();
+unexpected_handler set_unexpected(unexpected_handler  f ) throw();
+unexpected_handler get_unexpected() throw();
+void unexpected [[noreturn]] ();

 typedef void (*terminate_handler)();
-terminate_handler set_terminate(terminate_handler  f ) noexcept;
-terminate_handler get_terminate() noexcept;
-[[noreturn]] void terminate() noexcept;
+terminate_handler set_terminate(terminate_handler  f ) throw();
+terminate_handler get_terminate() throw();
+void terminate [[noreturn]] ();

-bool uncaught_exception() noexcept;
+bool uncaught_exception() throw();

 typedef unspecified exception_ptr;

-exception_ptr current_exception() noexcept;
+exception_ptr current_exception();
 void rethrow_exception [[noreturn]] (exception_ptr p);
-template<class E> exception_ptr make_exception_ptr(E e) noexcept;
+template<class E> exception_ptr make_exception_ptr(E e);

 class nested_exception
 {
 public:
-    nested_exception() noexcept;
-    nested_exception(const nested_exception&) noexcept = default;
-    nested_exception& operator=(const nested_exception&) noexcept = default;
+    nested_exception() throw();
+    nested_exception(const nested_exception&) throw() = default;
+    nested_exception& operator=(const nested_exception&) throw() = default;
    virtual ~nested_exception() = default;

    // access functions
-    [[noreturn]] void rethrow_nested() const;
-    exception_ptr nested_ptr() const noexcept;
+    void rethrow_nested [[noreturn]] () const;
+    exception_ptr nested_ptr() const;
 };

-template <class T> [[noreturn]] void throw_with_nested(T&& t);
+template <class T> void throw_with_nested [[noreturn]] (T&& t);
 template <class E> void rethrow_if_nested(const E& e);

 }  // std
@@ -88,65 +88,65 @@ namespace std  // purposefully not using versioning namespace
 class _LIBCPP_EXCEPTION_ABI exception
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY exception() _NOEXCEPT {}
-    virtual ~exception() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY exception() throw() {}
+    virtual ~exception() throw();
+    virtual const char* what() const throw();
 };

 class _LIBCPP_EXCEPTION_ABI bad_exception
    : public exception
 {
 public:
-    _LIBCPP_INLINE_VISIBILITY bad_exception() _NOEXCEPT {}
-    virtual ~bad_exception() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY bad_exception() throw() {}
+    virtual ~bad_exception() throw();
+    virtual const char* what() const throw();
 };

 typedef void (*unexpected_handler)();
-_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) _NOEXCEPT;
-_LIBCPP_VISIBLE unexpected_handler get_unexpected() _NOEXCEPT;
-_ATTRIBUTE(noreturn) _LIBCPP_VISIBLE void unexpected();
+_LIBCPP_VISIBLE unexpected_handler set_unexpected(unexpected_handler) throw();
+_LIBCPP_VISIBLE unexpected_handler get_unexpected() throw();
+_LIBCPP_VISIBLE void unexpected();

 typedef void (*terminate_handler)();
-_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) _NOEXCEPT;
-_LIBCPP_VISIBLE terminate_handler get_terminate() _NOEXCEPT;
-_ATTRIBUTE(noreturn) _LIBCPP_VISIBLE void terminate() _NOEXCEPT;
+_LIBCPP_VISIBLE terminate_handler set_terminate(terminate_handler) throw();
+_LIBCPP_VISIBLE terminate_handler get_terminate() throw();
+_LIBCPP_VISIBLE void terminate() __attribute__((__noreturn__));

-_LIBCPP_VISIBLE bool uncaught_exception() _NOEXCEPT;
+_LIBCPP_VISIBLE bool uncaught_exception() throw();

 class exception_ptr;

-exception_ptr current_exception() _NOEXCEPT;
-_ATTRIBUTE(noreturn) void rethrow_exception(exception_ptr);
+exception_ptr current_exception();
+void rethrow_exception(exception_ptr);  // noreturn

 class _LIBCPP_VISIBLE exception_ptr
 {
    void* __ptr_;
 public:
-    _LIBCPP_INLINE_VISIBILITY exception_ptr() _NOEXCEPT : __ptr_() {}
-    _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) _NOEXCEPT : __ptr_() {}
-    exception_ptr(const exception_ptr&) _NOEXCEPT;
-    exception_ptr& operator=(const exception_ptr&) _NOEXCEPT;
-    ~exception_ptr() _NOEXCEPT;
+    _LIBCPP_INLINE_VISIBILITY exception_ptr()  : __ptr_() {}
+    _LIBCPP_INLINE_VISIBILITY exception_ptr(nullptr_t) : __ptr_() {}
+    exception_ptr(const exception_ptr&);
+    exception_ptr& operator=(const exception_ptr&);
+    ~exception_ptr();

    _LIBCPP_INLINE_VISIBILITY
    // explicit
-        operator bool() const _NOEXCEPT {return __ptr_ != nullptr;}
+        operator bool() const {return __ptr_ != nullptr;}

    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
+    bool operator==(const exception_ptr& __x, const exception_ptr& __y)
        {return __x.__ptr_ == __y.__ptr_;}
    friend _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const exception_ptr& __x, const exception_ptr& __y) _NOEXCEPT
+    bool operator!=(const exception_ptr& __x, const exception_ptr& __y)
        {return !(__x == __y);}

-    friend exception_ptr current_exception() _NOEXCEPT;
-    _ATTRIBUTE(noreturn) friend void rethrow_exception(exception_ptr);
+    friend exception_ptr current_exception();
+    friend void rethrow_exception(exception_ptr);  // noreturn
 };

 template<class _E>
 exception_ptr
-make_exception_ptr(_E __e) _NOEXCEPT
+make_exception_ptr(_E __e)
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
    try
@@ -166,14 +166,14 @@ class _LIBCPP_EXCEPTION_ABI nested_exception
 {
    exception_ptr __ptr_;
 public:
-    nested_exception() _NOEXCEPT;
-//     nested_exception(const nested_exception&) noexcept = default;
-//     nested_exception& operator=(const nested_exception&) noexcept = default;
-    virtual ~nested_exception() _NOEXCEPT;
+    nested_exception();
+//     nested_exception(const nested_exception&) throw() = default;
+//     nested_exception& operator=(const nested_exception&) throw() = default;
+    virtual ~nested_exception();

    // access functions
-    _ATTRIBUTE(noreturn) void rethrow_nested() const;
-    _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const _NOEXCEPT {return __ptr_;}
+    void rethrow_nested /*[[noreturn]]*/ () const;
+    _LIBCPP_INLINE_VISIBILITY exception_ptr nested_ptr() const {return __ptr_;}
 };

 template <class _Tp>
@@ -185,10 +185,9 @@ struct __nested
 };

 template <class _Tp>
-_ATTRIBUTE(noreturn)
 void
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested(_Tp&& __t, typename enable_if<
+throw_with_nested /*[[noreturn]]*/ (_Tp&& __t, typename enable_if<
                  is_class<typename remove_reference<_Tp>::type>::value &&
                  !is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
                                    >::type* = 0)
@@ -199,15 +198,14 @@ 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>(_VSTD::forward<_Tp>(__t));
+    throw __nested<typename remove_reference<_Tp>::type>(_STD::forward<_Tp>(__t));
 #endif
 }

 template <class _Tp>
-_ATTRIBUTE(noreturn)
 void
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-throw_with_nested(_Tp&& __t, typename enable_if<
+throw_with_nested /*[[noreturn]]*/ (_Tp&& __t, typename enable_if<
                  !is_class<typename remove_reference<_Tp>::type>::value ||
                  is_base_of<nested_exception, typename remove_reference<_Tp>::type>::value
                                    >::type* = 0)
@@ -218,7 +216,7 @@ throw_with_nested (_Tp& __t, typename enable_if<
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    throw _VSTD::forward<_Tp>(__t);
+    throw _STD::forward<_Tp>(__t);
 #endif
 }

--- a/include/ext/__hash
+++ b/include/ext/__hash
@@ -1,46 +0,0 @@
-// -*- C++ -*-
-//===------------------------- hash_set ------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_EXT_HASH
-#define _LIBCPP_EXT_HASH
-
-#pragma GCC system_header
-
-#include <string>
-#include <cstring>
-
-namespace __gnu_cxx {
-using namespace std;
-
-template <typename T> struct _LIBCPP_VISIBLE hash : public std::hash<T>
-    { };
-
-template <> struct _LIBCPP_VISIBLE hash<const char*>
-    : public unary_function<const char*, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const char *__c) const _NOEXCEPT
-    {
-        return __do_string_hash(__c, __c + strlen(__c));
-    }
-};
-
-template <> struct _LIBCPP_VISIBLE hash<char *>
-    : public unary_function<char*, size_t>
-{
-    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char *__c) const _NOEXCEPT
-    {
-        return __do_string_hash<const char *>(__c, __c + strlen(__c));
-    }
-};
-}
-
-#endif _LIBCPP_EXT_HASH
--- a/include/ext/hash_map
+++ b/include/ext/hash_map
@@ -203,11 +203,8 @@ template <class Key, class T, class Hash, class Pred, class Alloc>
 #include <__hash_table>
 #include <functional>
 #include <stdexcept>
-#include <ext/__hash>

-#if __DEPRECATED
 #warning Use of the header <ext/hash_map> is deprecated.  Migrate to <unordered_map>
-#endif

 #pragma GCC system_header

@@ -344,9 +341,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, _VSTD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -469,7 +466,6 @@ public:
    // types
    typedef _Key                                           key_type;
    typedef _Tp                                            mapped_type;
-    typedef _Tp                                            data_type;
    typedef _Hash                                          hasher;
    typedef _Pred                                          key_equal;
    typedef _Alloc                                         allocator_type;
@@ -553,8 +549,6 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    pair<iterator, bool> insert(const value_type& __x)
        {return __table_.__insert_unique(__x);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
    template <class _InputIterator>
        void insert(_InputIterator __first, _InputIterator __last);

@@ -672,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, _VSTD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _VSTD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
-    return _VSTD::move(__h);
+    return _STD::move(__h);
 }

 template <class _Key, class _Tp, class _Hash, class _Pred, class _Alloc>
@@ -748,7 +742,6 @@ public:
    // types
    typedef _Key                                           key_type;
    typedef _Tp                                            mapped_type;
-    typedef _Tp                                            data_type;
    typedef _Hash                                          hasher;
    typedef _Pred                                          key_equal;
    typedef _Alloc                                         allocator_type;
@@ -830,8 +823,6 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
    template <class _InputIterator>
        void insert(_InputIterator __first, _InputIterator __last);

@@ -972,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 (_VSTD::distance(__xeq.first, __xeq.second) !=
-            _VSTD::distance(__yeq.first, __yeq.second) ||
-                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_STD::distance(__xeq.first, __xeq.second) !=
+            _STD::distance(__yeq.first, __yeq.second) ||
+                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
            return false;
        __i = __xeq.second;
    }
--- a/include/ext/hash_set
+++ b/include/ext/hash_set
@@ -196,17 +196,14 @@ template <class Value, class Hash, class Pred, class Alloc>
 #include <__config>
 #include <__hash_table>
 #include <functional>
-#include <ext/__hash>

-#if __DEPRECATED
 #warning Use of the header <ext/hash_set> is deprecated.  Migrate to <unordered_set>
-#endif

 namespace __gnu_cxx {

 using namespace std;

-template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>,
+template <class _Value, class _Hash = std::hash<_Value>, class _Pred = equal_to<_Value>,
          class _Alloc = allocator<_Value> >
 class _LIBCPP_VISIBLE hash_set
 {
@@ -275,8 +272,6 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    pair<iterator, bool> insert(const value_type& __x)
        {return __table_.__insert_unique(__x);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}
    template <class _InputIterator>
        void insert(_InputIterator __first, _InputIterator __last);

@@ -495,8 +490,6 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);}
-    _LIBCPP_INLINE_VISIBILITY
-    iterator insert(const_iterator, const value_type& __x) {return insert(__x);}
    template <class _InputIterator>
        void insert(_InputIterator __first, _InputIterator __last);

@@ -634,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 (_VSTD::distance(__xeq.first, __xeq.second) !=
-            _VSTD::distance(__yeq.first, __yeq.second) ||
-                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_STD::distance(__xeq.first, __xeq.second) !=
+            _STD::distance(__yeq.first, __yeq.second) ||
+                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
            return false;
        __i = __xeq.second;
    }
--- a/include/forward_list
+++ b/include/forward_list
@@ -34,8 +34,7 @@ public:
    typedef <details> iterator;
    typedef <details> const_iterator;

-    forward_list()
-        noexcept(is_nothrow_default_constructible<allocator_type>::value);
+    forward_list();
    explicit forward_list(const allocator_type& a);
    explicit forward_list(size_type n);
    forward_list(size_type n, const value_type& v);
@@ -46,8 +45,7 @@ public:
        forward_list(InputIterator first, InputIterator last, const allocator_type& a);
    forward_list(const forward_list& x);
    forward_list(const forward_list& x, const allocator_type& a);
-    forward_list(forward_list&& x)
-        noexcept(is_nothrow_move_constructible<allocator_type>::value);
+    forward_list(forward_list&& x);
    forward_list(forward_list&& x, const allocator_type& a);
    forward_list(initializer_list<value_type> il);
    forward_list(initializer_list<value_type> il, const allocator_type& a);
@@ -55,10 +53,7 @@ public:
    ~forward_list();

    forward_list& operator=(const forward_list& x);
-    forward_list& operator=(forward_list&& x)
-        noexcept(
-             allocator_type::propagate_on_container_move_assignment::value &&
-             is_nothrow_move_assignable<allocator_type>::value);
+    forward_list& operator=(forward_list&& x);
    forward_list& operator=(initializer_list<value_type> il);

    template <class InputIterator>
@@ -66,22 +61,22 @@ public:
    void assign(size_type n, const value_type& v);
    void assign(initializer_list<value_type> il);

-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;

-    iterator       begin() noexcept;
-    const_iterator begin() const noexcept;
-    iterator       end() noexcept;
-    const_iterator end() const noexcept;
+    iterator       begin();
+    const_iterator begin() const;
+    iterator       end();
+    const_iterator end() const;

-    const_iterator cbegin() const noexcept;
-    const_iterator cend() const noexcept;
+    const_iterator cbegin() const;
+    const_iterator cend() const;

-    iterator       before_begin() noexcept;
-    const_iterator before_begin() const noexcept;
-    const_iterator cbefore_begin() const noexcept;
+    iterator       before_begin();
+    const_iterator before_begin() const;
+    const_iterator cbefore_begin() const;

-    bool empty() const noexcept;
-    size_type max_size() const noexcept;
+    bool empty() const;
+    size_type max_size() const;

    reference       front();
    const_reference front() const;
@@ -105,13 +100,11 @@ public:
    iterator erase_after(const_iterator p);
    iterator erase_after(const_iterator first, const_iterator last);

-    void swap(forward_list& x)
-        noexcept(!allocator_type::propagate_on_container_swap::value ||
-                 __is_nothrow_swappable<allocator_type>::value);
+    void swap(forward_list& x);

    void resize(size_type n);
    void resize(size_type n, const value_type& v);
-    void clear() noexcept;
+    void clear();

    void splice_after(const_iterator p, forward_list& x);
    void splice_after(const_iterator p, forward_list&& x);
@@ -131,7 +124,7 @@ public:
    template <class Compare> void merge(forward_list&& x, Compare comp);
    void sort();
    template <class Compare> void sort(Compare comp);
-    void reverse() noexcept;
+    void reverse();
 };

 template <class T, class Allocator>
@@ -159,8 +152,7 @@ template <class T, class Allocator>
                    const forward_list<T, Allocator>& y);

 template <class T, class Allocator>
-    void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y)
-         noexcept(noexcept(x.swap(y)));
+    void swap(forward_list<T, Allocator>& x, forward_list<T, Allocator>& y);

 }  // std

@@ -178,7 +170,7 @@ template <class T, class Allocator>

 _LIBCPP_BEGIN_NAMESPACE_STD

-template <class _Tp, class _VoidPtr> struct __forward_list_node;
+template <class, class> struct __forward_list_node;

 template <class _NodePtr>
 struct __forward_begin_node
@@ -208,8 +200,8 @@ struct __forward_list_node
    value_type __value_;
 };

-template<class _Tp, class _Alloc> class forward_list;
-template<class _NodeConstPtr> class __forward_list_const_iterator;
+template<class, class> class forward_list;
+template<class> class __forward_list_const_iterator;

 template <class _NodePtr>
 class _LIBCPP_VISIBLE __forward_list_iterator
@@ -219,7 +211,7 @@ class _LIBCPP_VISIBLE __forward_list_iterator
    __node_pointer __ptr_;

    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_iterator(__node_pointer __p) _NOEXCEPT : __ptr_(__p) {}
+    explicit __forward_list_iterator(__node_pointer __p) : __ptr_(__p) {}

    template<class, class> friend class forward_list;
    template<class> friend class __forward_list_const_iterator;
@@ -240,7 +232,7 @@ public:
                                                              pointer;

    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_iterator() _NOEXCEPT : __ptr_(nullptr) {}
+    __forward_list_iterator() : __ptr_(nullptr) {}

    _LIBCPP_INLINE_VISIBILITY
    reference operator*() const {return __ptr_->__value_;}
@@ -279,7 +271,7 @@ class _LIBCPP_VISIBLE __forward_list_const_iterator
    __node_const_pointer __ptr_;

    _LIBCPP_INLINE_VISIBILITY
-    explicit __forward_list_const_iterator(__node_const_pointer __p) _NOEXCEPT
+    explicit __forward_list_const_iterator(__node_const_pointer __p)
        : __ptr_(__p) {}

    typedef typename remove_const
@@ -311,9 +303,9 @@ public:
                                                              pointer;

    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_const_iterator() _NOEXCEPT : __ptr_(nullptr) {}
+    __forward_list_const_iterator() : __ptr_(nullptr) {}
    _LIBCPP_INLINE_VISIBILITY
-    __forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p) _NOEXCEPT
+    __forward_list_const_iterator(__forward_list_iterator<__node_pointer> __p)
        : __ptr_(__p.__ptr_) {}

    _LIBCPP_INLINE_VISIBILITY
@@ -369,47 +361,41 @@ protected:
    __compressed_pair<__begin_node, __node_allocator> __before_begin_;

    _LIBCPP_INLINE_VISIBILITY
-    __node_pointer        __before_begin() _NOEXCEPT
+    __node_pointer        __before_begin()
        {return pointer_traits<__node_pointer>::pointer_to(
                                static_cast<__node&>(__before_begin_.first()));}
    _LIBCPP_INLINE_VISIBILITY
-    __node_const_pointer  __before_begin() const _NOEXCEPT
+    __node_const_pointer  __before_begin() const
        {return pointer_traits<__node_const_pointer>::pointer_to(
                          static_cast<const __node&>(__before_begin_.first()));}

    _LIBCPP_INLINE_VISIBILITY
-          __node_allocator& __alloc() _NOEXCEPT
-            {return __before_begin_.second();}
+          __node_allocator& __alloc()       {return __before_begin_.second();}
    _LIBCPP_INLINE_VISIBILITY
-    const __node_allocator& __alloc() const _NOEXCEPT
-        {return __before_begin_.second();}
+    const __node_allocator& __alloc() const {return __before_begin_.second();}

    typedef __forward_list_iterator<__node_pointer>             iterator;
    typedef __forward_list_const_iterator<__node_const_pointer> const_iterator;

    _LIBCPP_INLINE_VISIBILITY
    __forward_list_base()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
        : __before_begin_(__begin_node()) {}
    _LIBCPP_INLINE_VISIBILITY
    __forward_list_base(const allocator_type& __a)
        : __before_begin_(__begin_node(), __node_allocator(__a)) {}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-public:
-    __forward_list_base(__forward_list_base&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<__node_allocator>::value);
+    __forward_list_base(__forward_list_base&& __x);
    __forward_list_base(__forward_list_base&& __x, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 private:
    __forward_list_base(const __forward_list_base&);
    __forward_list_base& operator=(const __forward_list_base&);
+protected:

-public:
    ~__forward_list_base();

-protected:
    _LIBCPP_INLINE_VISIBILITY
    void __copy_assign_alloc(const __forward_list_base& __x)
        {__copy_assign_alloc(__x, integral_constant<bool,
@@ -417,17 +403,11 @@ protected:

    _LIBCPP_INLINE_VISIBILITY
    void __move_assign_alloc(__forward_list_base& __x)
-        _NOEXCEPT_(!__node_traits::propagate_on_container_move_assignment::value ||
-                   is_nothrow_move_assignable<__node_allocator>::value)
        {__move_assign_alloc(__x, integral_constant<bool,
              __node_traits::propagate_on_container_move_assignment::value>());}

-public:
-    void swap(__forward_list_base& __x)
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<__node_allocator>::value);
-protected:
-    void clear() _NOEXCEPT;
+    void swap(__forward_list_base& __x);
+    void clear();

 private:
    _LIBCPP_INLINE_VISIBILITY
@@ -441,30 +421,24 @@ private:
    }

    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign_alloc(__forward_list_base& __x, false_type) _NOEXCEPT
-        {}
+    void __move_assign_alloc(__forward_list_base& __x, false_type) {}
    _LIBCPP_INLINE_VISIBILITY
    void __move_assign_alloc(__forward_list_base& __x, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<__node_allocator>::value)
-        {__alloc() = _VSTD::move(__x.__alloc());}
+        {__alloc() = _STD::move(__x.__alloc());}

    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y)
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<__node_allocator>::value)
        {__swap_alloc(__x, __y, integral_constant<bool,
                         __node_traits::propagate_on_container_swap::value>());}
    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y,
                                                                     false_type)
-        _NOEXCEPT
        {}
    _LIBCPP_INLINE_VISIBILITY
    static void __swap_alloc(__node_allocator& __x, __node_allocator& __y,
                                                                      true_type)
-        _NOEXCEPT_(__is_nothrow_swappable<__node_allocator>::value)
        {
-            using _VSTD::swap;
+            using _STD::swap;
            swap(__x, __y);
        }
 };
@@ -474,8 +448,7 @@ private:
 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_(_VSTD::move(__x.__before_begin_))
+    : __before_begin_(_STD::move(__x.__before_begin_))
 {
    __x.__before_begin()->__next_ = nullptr;
 }
@@ -505,23 +478,21 @@ template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 __forward_list_base<_Tp, _Alloc>::swap(__forward_list_base& __x)
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<__node_allocator>::value)
 {
    __swap_alloc(__alloc(), __x.__alloc());
-    using _VSTD::swap;
+    using _STD::swap;
    swap(__before_begin()->__next_, __x.__before_begin()->__next_);
 }

 template <class _Tp, class _Alloc>
 void
-__forward_list_base<_Tp, _Alloc>::clear() _NOEXCEPT
+__forward_list_base<_Tp, _Alloc>::clear()
 {
    __node_allocator& __a = __alloc();
    for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
    {
        __node_pointer __next = __p->__next_;
-        __node_traits::destroy(__a, _VSTD::addressof(__p->__value_));
+        __node_traits::destroy(__a, _STD::addressof(__p->__value_));
        __node_traits::deallocate(__a, __p, 1);
        __p = __next;
    }
@@ -533,11 +504,6 @@ class _LIBCPP_VISIBLE forward_list
    : private __forward_list_base<_Tp, _Alloc>
 {
    typedef __forward_list_base<_Tp, _Alloc> base;
-    typedef typename base::__node_allocator  __node_allocator;
-    typedef typename base::__node            __node;
-    typedef typename base::__node_traits     __node_traits;
-    typedef typename base::__node_pointer    __node_pointer;
-
 public:
    typedef _Tp    value_type;
    typedef _Alloc allocator_type;
@@ -552,10 +518,7 @@ public:
    typedef typename base::iterator       iterator;
    typedef typename base::const_iterator const_iterator;

-    _LIBCPP_INLINE_VISIBILITY
-    forward_list()
-        _NOEXCEPT_(is_nothrow_default_constructible<__node_allocator>::value)
-        {} // = default;
+    _LIBCPP_INLINE_VISIBILITY forward_list() {} // = default;
    explicit forward_list(const allocator_type& __a);
    explicit forward_list(size_type __n);
    forward_list(size_type __n, const value_type& __v);
@@ -575,28 +538,19 @@ public:
    forward_list(const forward_list& __x, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
-    forward_list(forward_list&& __x)
-        _NOEXCEPT_(is_nothrow_move_constructible<base>::value)
-        : base(_VSTD::move(__x)) {}
+    forward_list(forward_list&& __x) : base(_STD::move(__x)) {}
    forward_list(forward_list&& __x, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    forward_list(initializer_list<value_type> __il);
    forward_list(initializer_list<value_type> __il, const allocator_type& __a);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    // ~forward_list() = default;

    forward_list& operator=(const forward_list& __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    forward_list& operator=(forward_list&& __x)
-        _NOEXCEPT_(
-             __node_traits::propagate_on_container_move_assignment::value &&
-             is_nothrow_move_assignable<allocator_type>::value);
+    forward_list& operator=(forward_list&& __x);
 #endif
-#ifndef  _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    forward_list& operator=(initializer_list<value_type> __il);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    template <class _InputIterator>
        typename enable_if
@@ -606,50 +560,36 @@ public:
        >::type
        assign(_InputIterator __f, _InputIterator __l);
    void assign(size_type __n, const value_type& __v);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    void assign(initializer_list<value_type> __il);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
-        {return allocator_type(base::__alloc());}
+    allocator_type get_allocator() const {return allocator_type(base::__alloc());}

    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT
-        {return       iterator(base::__before_begin()->__next_);}
+    iterator       begin()       {return       iterator(base::__before_begin()->__next_);}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin()->__next_);}
+    const_iterator begin() const {return const_iterator(base::__before_begin()->__next_);}
    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT
-        {return       iterator(nullptr);}
+    iterator       end()         {return       iterator(nullptr);}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end() const _NOEXCEPT
-        {return const_iterator(nullptr);}
+    const_iterator end() const   {return const_iterator(nullptr);}

    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin()->__next_);}
+    const_iterator cbegin() const {return const_iterator(base::__before_begin()->__next_);}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT
-        {return const_iterator(nullptr);}
+    const_iterator cend() const   {return const_iterator(nullptr);}

    _LIBCPP_INLINE_VISIBILITY
-    iterator       before_begin() _NOEXCEPT
-        {return       iterator(base::__before_begin());}
+    iterator       before_begin()        {return       iterator(base::__before_begin());}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator before_begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin());}
+    const_iterator before_begin() const  {return const_iterator(base::__before_begin());}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbefore_begin() const _NOEXCEPT
-        {return const_iterator(base::__before_begin());}
+    const_iterator cbefore_begin() const {return const_iterator(base::__before_begin());}

    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT
-        {return base::__before_begin()->__next_ == nullptr;}
+    bool empty() const {return base::__before_begin()->__next_ == nullptr;}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT
-        {return numeric_limits<size_type>::max();}
+    size_type max_size() const {return numeric_limits<size_type>::max();}

    _LIBCPP_INLINE_VISIBILITY
    reference       front()       {return base::__before_begin()->__next_->__value_;}
@@ -683,24 +623,19 @@ public:
            iterator
        >::type
        insert_after(const_iterator __p, _InputIterator __f, _InputIterator __l);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    iterator insert_after(const_iterator __p, initializer_list<value_type> __il)
        {return insert_after(__p, __il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    iterator erase_after(const_iterator __p);
    iterator erase_after(const_iterator __f, const_iterator __l);

    _LIBCPP_INLINE_VISIBILITY
-    void swap(forward_list& __x)
-        _NOEXCEPT_(!__node_traits::propagate_on_container_swap::value ||
-                   __is_nothrow_swappable<__node_allocator>::value)
-        {base::swap(__x);}
+    void swap(forward_list& __x) {base::swap(__x);}

    void resize(size_type __n);
    void resize(size_type __n, const value_type& __v);
    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {base::clear();}
+    void clear() {base::clear();}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
@@ -726,7 +661,7 @@ public:
    template <class _Compare>
        _LIBCPP_INLINE_VISIBILITY
        void merge(forward_list&& __x, _Compare __comp)
-        {merge(__x, _VSTD::move(__comp));}
+        {merge(__x, _STD::move(__comp));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    void merge(forward_list& __x) {merge(__x, __less<value_type>());}
@@ -734,13 +669,16 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    void sort() {sort(__less<value_type>());}
    template <class _Compare> void sort(_Compare __comp);
-    void reverse() _NOEXCEPT;
+    void reverse();

 private:
+    typedef typename base::__node_allocator  __node_allocator;
+    typedef typename base::__node            __node;
+    typedef typename base::__node_traits     __node_traits;
+    typedef typename base::__node_pointer    __node_pointer;

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    void __move_assign(forward_list& __x, true_type)
-        _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value);
+    void __move_assign(forward_list& __x, true_type);
    void __move_assign(forward_list& __x, false_type);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

@@ -774,7 +712,7 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
                                                             __p = __p->__next_)
        {
            __h.reset(__node_traits::allocate(__a, 1));
-            __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
+            __node_traits::construct(__a, _STD::addressof(__h->__value_));
            __h->__next_ = nullptr;
            __p->__next_ = __h.release();
        }
@@ -840,7 +778,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(_VSTD::move(__x), __a)
+    : base(_STD::move(__x), __a)
 {
    if (base::__alloc() != __x.__alloc())
    {
@@ -851,8 +789,6 @@ forward_list<_Tp, _Alloc>::forward_list(forward_list&& __x,

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp, class _Alloc>
 forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il)
 {
@@ -867,8 +803,6 @@ forward_list<_Tp, _Alloc>::forward_list(initializer_list<value_type> __il,
    insert_after(cbefore_begin(), __il.begin(), __il.end());
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp, class _Alloc>
 forward_list<_Tp, _Alloc>&
 forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
@@ -886,7 +820,6 @@ forward_list<_Tp, _Alloc>::operator=(const forward_list& __x)
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::__move_assign(forward_list& __x, true_type)
-    _NOEXCEPT_(is_nothrow_move_assignable<allocator_type>::value)
 {
    clear();
    base::__move_assign_alloc(__x);
@@ -911,9 +844,6 @@ template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 forward_list<_Tp, _Alloc>&
 forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)
-    _NOEXCEPT_(
-             __node_traits::propagate_on_container_move_assignment::value &&
-             is_nothrow_move_assignable<allocator_type>::value)
 {
    __move_assign(__x, integral_constant<bool,
          __node_traits::propagate_on_container_move_assignment::value>());
@@ -922,8 +852,6 @@ forward_list<_Tp, _Alloc>::operator=(forward_list&& __x)

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 forward_list<_Tp, _Alloc>&
@@ -933,8 +861,6 @@ forward_list<_Tp, _Alloc>::operator=(initializer_list<value_type> __il)
    return *this;
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp, class _Alloc>
 template <class _InputIterator>
 typename enable_if
@@ -945,7 +871,7 @@ typename enable_if
 forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
 {
    iterator __i = before_begin();
-    iterator __j = _VSTD::next(__i);
+    iterator __j = _STD::next(__i);
    iterator __e = end();
    for (; __j != __e && __f != __l; ++__i, ++__j, ++__f)
        *__j = *__f;
@@ -960,7 +886,7 @@ void
 forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
 {
    iterator __i = before_begin();
-    iterator __j = _VSTD::next(__i);
+    iterator __j = _STD::next(__i);
    iterator __e = end();
    for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
        *__j = __v;
@@ -970,8 +896,6 @@ forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
        erase_after(__i, __e);
 }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void
@@ -980,8 +904,6 @@ forward_list<_Tp, _Alloc>::assign(initializer_list<value_type> __il)
    assign(__il.begin(), __il.end());
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #ifndef _LIBCPP_HAS_NO_VARIADICS

@@ -993,8 +915,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, _VSTD::addressof(__h->__value_),
-                                  _VSTD::forward<_Args>(__args)...);
+    __node_traits::construct(__a, _STD::addressof(__h->__value_),
+                                  _STD::forward<_Args>(__args)...);
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -1008,7 +930,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, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -1022,7 +944,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, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -1034,7 +956,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, _VSTD::addressof(__p->__value_));
+    __node_traits::destroy(__a, _STD::addressof(__p->__value_));
    __node_traits::deallocate(__a, __p, 1);
 }

@@ -1050,8 +972,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, _VSTD::addressof(__h->__value_),
-                                  _VSTD::forward<_Args>(__args)...);
+    __node_traits::construct(__a, _STD::addressof(__h->__value_),
+                                  _STD::forward<_Args>(__args)...);
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -1067,7 +989,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, _VSTD::addressof(__h->__value_), _VSTD::move(__v));
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -1083,7 +1005,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, _VSTD::addressof(__h->__value_), __v);
+    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -1100,7 +1022,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, _VSTD::addressof(__h->__value_), __v);
+        __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
        __node_pointer __first = __h.release();
        __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1110,7 +1032,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, _VSTD::addressof(__h->__value_), __v);
+                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
                __last->__next_ = __h.release();
            }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1120,7 +1042,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, _VSTD::addressof(__first->__value_));
+                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
                __node_traits::deallocate(__a, __first, 1);
                __first = __next;
            }
@@ -1150,7 +1072,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, _VSTD::addressof(__h->__value_), *__f);
+        __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
        __node_pointer __first = __h.release();
        __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1160,7 +1082,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, _VSTD::addressof(__h->__value_), *__f);
+                __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
                __last->__next_ = __h.release();
            }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1170,7 +1092,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
            while (__first != nullptr)
            {
                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _VSTD::addressof(__first->__value_));
+                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
                __node_traits::deallocate(__a, __first, 1);
                __first = __next;
            }
@@ -1192,7 +1114,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, _VSTD::addressof(__n->__value_));
+    __node_traits::destroy(__a, _STD::addressof(__n->__value_));
    __node_traits::deallocate(__a, __n, 1);
    return iterator(__p->__next_);
 }
@@ -1213,7 +1135,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
            do
            {
                __p = __n->__next_;
-                __node_traits::destroy(__a, _VSTD::addressof(__n->__value_));
+                __node_traits::destroy(__a, _STD::addressof(__n->__value_));
                __node_traits::deallocate(__a, __n, 1);
                __n = __p;
            } while (__n != __e);
@@ -1246,7 +1168,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
                                                         __ptr = __ptr->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _VSTD::addressof(__h->__value_));
+                __node_traits::construct(__a, _STD::addressof(__h->__value_));
                __h->__next_ = nullptr;
                __ptr->__next_ = __h.release();
            }
@@ -1278,7 +1200,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, _VSTD::addressof(__h->__value_), __v);
+                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
                __h->__next_ = nullptr;
                __ptr->__next_ = __h.release();
            }
@@ -1313,7 +1235,7 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
                                        forward_list& __x,
                                        const_iterator __i)
 {
-    const_iterator __lm1 = _VSTD::next(__i);
+    const_iterator __lm1 = _STD::next(__i);
    if (__p != __i && __p != __lm1)
    {
        const_cast<__node_pointer>(__i.__ptr_)->__next_ =
@@ -1390,7 +1312,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
    {
        if (__i.__ptr_->__next_->__value_ == __v)
        {
-            iterator __j = _VSTD::next(__i, 2);
+            iterator __j = _STD::next(__i, 2);
            for (; __j != __e && *__j == __v; ++__j)
                ;
            erase_after(__i, __j);
@@ -1413,7 +1335,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
    {
        if (__pred(__i.__ptr_->__next_->__value_))
        {
-            iterator __j = _VSTD::next(__i, 2);
+            iterator __j = _STD::next(__i, 2);
            for (; __j != __e && __pred(*__j); ++__j)
                ;
            erase_after(__i, __j);
@@ -1433,7 +1355,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
    for (iterator __i = begin(), __e = end(); __i != __e;)
    {
-        iterator __j = _VSTD::next(__i);
+        iterator __j = _STD::next(__i);
        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
            ;
        if (__i.__ptr_->__next_ != __j.__ptr_)
@@ -1508,7 +1430,7 @@ void
 forward_list<_Tp, _Alloc>::sort(_Compare __comp)
 {
    base::__before_begin()->__next_ = __sort(base::__before_begin()->__next_,
-                                       _VSTD::distance(begin(), end()), __comp);
+                                       _STD::distance(begin(), end()), __comp);
 }

 template <class _Tp, class _Alloc>
@@ -1534,7 +1456,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 = _VSTD::next(iterator(__f1), __sz1 - 1).__ptr_;
+    __node_pointer __t = _STD::next(iterator(__f1), __sz1 - 1).__ptr_;
    __node_pointer __f2 = __t->__next_;
    __t->__next_ = nullptr;
    return __merge(__sort(__f1, __sz1, __comp),
@@ -1543,7 +1465,7 @@ forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,

 template <class _Tp, class _Alloc>
 void
-forward_list<_Tp, _Alloc>::reverse() _NOEXCEPT
+forward_list<_Tp, _Alloc>::reverse()
 {
    __node_pointer __p = base::__before_begin()->__next_;
    if (__p != nullptr)
@@ -1590,7 +1512,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 bool operator< (const forward_list<_Tp, _Alloc>& __x,
                const forward_list<_Tp, _Alloc>& __y)
 {
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(),
+    return _STD::lexicographical_compare(__x.begin(), __x.end(),
                                         __y.begin(), __y.end());
 }

@@ -1622,7 +1544,6 @@ template <class _Tp, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(forward_list<_Tp, _Alloc>& __x, forward_list<_Tp, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
--- a/include/fstream
+++ b/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_)
    {
-        _VSTD::swap(__extbuf_, __rhs.__extbuf_);
-        _VSTD::swap(__extbufnext_, __rhs.__extbufnext_);
-        _VSTD::swap(__extbufend_, __rhs.__extbufend_);
+        _STD::swap(__extbuf_, __rhs.__extbuf_);
+        _STD::swap(__extbufnext_, __rhs.__extbufnext_);
+        _STD::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;
    }
-    _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_);
+    _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_);
    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 = _VSTD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
+            size_t __nmemb = _STD::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>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
+    : basic_istream<char_type, traits_type>(_STD::move(__rhs)),
+      __sb_(_STD::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=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
+    basic_istream<char_type, traits_type>::operator=(_STD::move(__rhs));
+    __sb_ = _STD::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>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
+    : basic_ostream<char_type, traits_type>(_STD::move(__rhs)),
+      __sb_(_STD::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=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
+    basic_ostream<char_type, traits_type>::operator=(_STD::move(__rhs));
+    __sb_ = _STD::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>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
+    : basic_iostream<char_type, traits_type>(_STD::move(__rhs)),
+      __sb_(_STD::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=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
+    basic_iostream<char_type, traits_type>::operator=(_STD::move(__rhs));
+    __sb_ = _STD::move(__rhs.__sb_);
    return *this;
 }

--- a/include/functional
+++ b/include/functional
@@ -43,16 +43,16 @@ public:
    typedef see below result_type; // Not always defined

    // construct/copy/destroy
-    reference_wrapper(T&) noexcept;
+    reference_wrapper(T&);
    reference_wrapper(T&&) = delete; // do not bind to temps
-    reference_wrapper(const reference_wrapper<T>& x) noexcept;
+    reference_wrapper(const reference_wrapper<T>& x);

    // assignment
-    reference_wrapper& operator=(const reference_wrapper<T>& x) noexcept;
+    reference_wrapper& operator=(const reference_wrapper<T>& x);

    // access
-    operator T& () const noexcept;
-    T& get() const noexcept;
+    operator T& () const;
+    T& get() const;

    // invoke
    template <class... ArgTypes>
@@ -60,13 +60,13 @@ public:
          operator() (ArgTypes&&...) const;
 };

-template <class T> reference_wrapper<T> ref(T& t) noexcept;
+template <class T> reference_wrapper<T> ref(T& t);
 template <class T> void ref(const T&& t) = delete;
-template <class T> reference_wrapper<T> ref(reference_wrapper<T>t) noexcept;
+template <class T> reference_wrapper<T> ref(reference_wrapper<T>t);

-template <class T> reference_wrapper<const T> cref(const T& t) noexcept;
+template <class T> reference_wrapper<const T> cref(const T& t);
 template <class T> void cref(const T&& t) = delete;
-template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t) noexcept;
+template <class T> reference_wrapper<const T> cref(reference_wrapper<T> t);

 template <class T>
 struct plus : binary_function<T, T, T>
@@ -365,16 +365,16 @@ public:
    typedef R result_type;

    // construct/copy/destroy:
-    function() noexcept;
-    function(nullptr_t) noexcept;
+    function();
+    function(nullptr_t);
    function(const function&);
-    function(function&&) noexcept;
+    function(function&&);
    template<class F>
      function(F);
    template<Allocator Alloc>
-      function(allocator_arg_t, const Alloc&) noexcept;
+      function(allocator_arg_t, const Alloc&);
    template<Allocator Alloc>
-      function(allocator_arg_t, const Alloc&, nullptr_t) noexcept;
+      function(allocator_arg_t, const Alloc&, nullptr_t);
    template<Allocator Alloc>
      function(allocator_arg_t, const Alloc&, const function&);
    template<Allocator Alloc>
@@ -383,48 +383,54 @@ public:
      function(allocator_arg_t, const Alloc&, F);

    function& operator=(const function&);
-    function& operator=(function&&) noexcept;
-    function& operator=(nullptr_t) noexcept;
+    function& operator=(function&&);
+    function& operator=(nullptr_t);
    template<class F>
      function& operator=(F&&);
    template<class F>
-      function& operator=(reference_wrapper<F>) noexcept;
+      function& operator=(reference_wrapper<F>);

    ~function();

    // function modifiers:
-    void swap(function&) noexcept;
+    void swap(function&);
    template<class F, class Alloc>
      void assign(F&&, const Alloc&);

    // function capacity:
-    explicit operator bool() const noexcept;
+    explicit operator bool() const;
+
+    // deleted overloads close possible hole in the type system
+    template<class R2, class... ArgTypes2>
+      bool operator==(const function<R2(ArgTypes2...)>&) = delete;
+    template<class R2, class... ArgTypes2>
+      bool operator!=(const function<R2(ArgTypes2...)>&) = delete;

    // function invocation:
    R operator()(ArgTypes...) const;

    // function target access:
-    const std::type_info& target_type() const noexcept;
-    template <typename T>       T* target() noexcept;
-    template <typename T> const T* target() const noexcept;
+    const std::type_info& target_type() const;
+    template <typename T>       T* target();
+    template <typename T> const T* target() const;
 };

 // Null pointer comparisons:
 template <class R, class ... ArgTypes>
-  bool operator==(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+  bool operator==(const function<R(ArgTypes...)>&, nullptr_t);

 template <class R, class ... ArgTypes>
-  bool operator==(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
+  bool operator==(nullptr_t, const function<R(ArgTypes...)>&);

 template <class R, class ... ArgTypes>
-  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t) noexcept;
+  bool operator!=(const function<R(ArgTypes...)>&, nullptr_t);

 template <class  R, class ... ArgTypes>
-  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&) noexcept;
+  bool operator!=(nullptr_t, const function<R(ArgTypes...)>&);

 // specialized algorithms:
 template <class  R, class ... ArgTypes>
-  void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&) noexcept;
+  void swap(function<R(ArgTypes...)>&, function<R(ArgTypes...)>&);

 template <class T> struct hash;

@@ -884,7 +890,7 @@ public:
       typename __invoke_return<type, _ArgTypes...>::type
          operator() (_ArgTypes&&... __args)
          {
-              return __invoke(__f_, _VSTD::forward<_ArgTypes>(__args)...);
+              return __invoke(__f_, _STD::forward<_ArgTypes>(__args)...);
          }
 };

@@ -974,12 +980,12 @@ public:
    _LIBCPP_INLINE_VISIBILITY virtual ~__base() {}
    virtual __base* __clone() const = 0;
    virtual void __clone(__base*) const = 0;
-    virtual void destroy() _NOEXCEPT = 0;
-    virtual void destroy_deallocate() _NOEXCEPT = 0;
+    virtual void destroy() = 0;
+    virtual void destroy_deallocate() = 0;
    virtual _R operator()(_ArgTypes&& ...) = 0;
 #ifndef _LIBCPP_NO_RTTI
-    virtual const void* target(const type_info&) const _NOEXCEPT = 0;
-    virtual const std::type_info& target_type() const _NOEXCEPT = 0;
+    virtual const void* target(const type_info&) const = 0;
+    virtual const std::type_info& target_type() const = 0;
 #endif  // _LIBCPP_NO_RTTI
 };

@@ -992,17 +998,17 @@ class __func<_F, _Alloc, _R(_ArgTypes...)>
    __compressed_pair<_F, _Alloc> __f_;
 public:
    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(_F __f) : __f_(_VSTD::move(__f)) {}
+    explicit __func(_F __f) : __f_(_STD::move(__f)) {}
    _LIBCPP_INLINE_VISIBILITY
-    explicit __func(_F __f, _Alloc __a) : __f_(_VSTD::move(__f), _VSTD::move(__a)) {}
+    explicit __func(_F __f, _Alloc __a) : __f_(_STD::move(__f), _STD::move(__a)) {}
    virtual __base<_R(_ArgTypes...)>* __clone() const;
    virtual void __clone(__base<_R(_ArgTypes...)>*) const;
-    virtual void destroy() _NOEXCEPT;
-    virtual void destroy_deallocate() _NOEXCEPT;
+    virtual void destroy();
+    virtual void destroy_deallocate();
    virtual _R operator()(_ArgTypes&& ... __arg);
 #ifndef _LIBCPP_NO_RTTI
-    virtual const void* target(const type_info&) const _NOEXCEPT;
-    virtual const std::type_info& target_type() const _NOEXCEPT;
+    virtual const void* target(const type_info&) const;
+    virtual const std::type_info& target_type() const;
 #endif  // _LIBCPP_NO_RTTI
 };

@@ -1027,14 +1033,14 @@ __func<_F, _Alloc, _R(_ArgTypes...)>::__clone(__base<_R(_ArgTypes...)>* __p) con

 template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 void
-__func<_F, _Alloc, _R(_ArgTypes...)>::destroy() _NOEXCEPT
+__func<_F, _Alloc, _R(_ArgTypes...)>::destroy()
 {
    __f_.~__compressed_pair<_F, _Alloc>();
 }

 template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 void
-__func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate() _NOEXCEPT
+__func<_F, _Alloc, _R(_ArgTypes...)>::destroy_deallocate()
 {
    typedef typename _Alloc::template rebind<__func>::other _A;
    _A __a(__f_.second());
@@ -1046,14 +1052,14 @@ template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 _R
 __func<_F, _Alloc, _R(_ArgTypes...)>::operator()(_ArgTypes&& ... __arg)
 {
-    return __invoke(__f_.first(), _VSTD::forward<_ArgTypes>(__arg)...);
+    return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
 }

 #ifndef _LIBCPP_NO_RTTI

 template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 const void*
-__func<_F, _Alloc, _R(_ArgTypes...)>::target(const type_info& __ti) const _NOEXCEPT
+__func<_F, _Alloc, _R(_ArgTypes...)>::target(const type_info& __ti) const
 {
    if (__ti == typeid(_F))
        return &__f_.first();
@@ -1062,7 +1068,7 @@ __func<_F, _Alloc, _R(_ArgTypes...)>::target(const type_info& __ti) const _NOEXC

 template<class _F, class _Alloc, class _R, class ..._ArgTypes>
 const std::type_info&
-__func<_F, _Alloc, _R(_ArgTypes...)>::target_type() const _NOEXCEPT
+__func<_F, _Alloc, _R(_ArgTypes...)>::target_type() const
 {
    return typeid(_F);
 }
@@ -1101,56 +1107,41 @@ class _LIBCPP_VISIBLE function<_R(_ArgTypes...)>
    template <class _R2, class ..._A>
        _LIBCPP_INLINE_VISIBILITY
        static bool __not_null(const function<_R(_A...)>& __p) {return __p;}
-
-    template <class _F, bool = __invokable<_F&, _ArgTypes...>::value>
-        struct __callable;
-    template <class _F>
-        struct __callable<_F, true>
-        {
-            static const bool value =
-                is_convertible<typename __invoke_of<_F&, _ArgTypes...>::type,
-                               _R>::value;
-        };
-    template <class _F>
-        struct __callable<_F, false>
-        {
-            static const bool value = false;
-        };
 public:
    typedef _R result_type;

    // construct/copy/destroy:
    _LIBCPP_INLINE_VISIBILITY
-    function() _NOEXCEPT : __f_(0) {}
+    function() : __f_(0) {}
    _LIBCPP_INLINE_VISIBILITY
-    function(nullptr_t) _NOEXCEPT : __f_(0) {}
+    function(nullptr_t) : __f_(0) {}
    function(const function&);
-    function(function&&) _NOEXCEPT;
+    function(function&&);
    template<class _F>
      function(_F,
-               typename enable_if<__callable<_F>::value>::type* = 0);
+               typename enable_if<!is_integral<_F>::value>::type* = 0);

    template<class _Alloc>
      _LIBCPP_INLINE_VISIBILITY
-      function(allocator_arg_t, const _Alloc&) _NOEXCEPT : __f_(0) {}
+      function(allocator_arg_t, const _Alloc&) : __f_(0) {}
    template<class _Alloc>
      _LIBCPP_INLINE_VISIBILITY
-      function(allocator_arg_t, const _Alloc&, nullptr_t) _NOEXCEPT : __f_(0) {}
+      function(allocator_arg_t, const _Alloc&, nullptr_t) : __f_(0) {}
    template<class _Alloc>
      function(allocator_arg_t, const _Alloc&, const function&);
    template<class _Alloc>
      function(allocator_arg_t, const _Alloc&, function&&);
    template<class _F, class _Alloc>
      function(allocator_arg_t, const _Alloc& __a, _F __f,
-               typename enable_if<__callable<_F>::value>::type* = 0);
+               typename enable_if<!is_integral<_F>::value>::type* = 0);

    function& operator=(const function&);
-    function& operator=(function&&) _NOEXCEPT;
-    function& operator=(nullptr_t) _NOEXCEPT;
+    function& operator=(function&&);
+    function& operator=(nullptr_t);
    template<class _F>
      typename enable_if
      <
-        __callable<typename decay<_F>::type>::value,
+        !is_integral<typename decay<_F>::type>::value,
        function&
      >::type
      operator=(_F&&);
@@ -1158,15 +1149,15 @@ public:
    ~function();

    // function modifiers:
-    void swap(function&) _NOEXCEPT;
+    void swap(function&);
    template<class _F, class _Alloc>
      _LIBCPP_INLINE_VISIBILITY
      void assign(_F&& __f, const _Alloc& __a)
-        {function(allocator_arg, __a, _VSTD::forward<_F>(__f)).swap(*this);}
+        {function(allocator_arg, __a, _STD::forward<_F>(__f)).swap(*this);}

    // function capacity:
    _LIBCPP_INLINE_VISIBILITY
-    /*explicit*/ operator bool() const _NOEXCEPT {return __f_;}
+    /*explicit*/ operator bool() const {return __f_;}

    // deleted overloads close possible hole in the type system
    template<class _R2, class... _ArgTypes2>
@@ -1179,9 +1170,9 @@ public:

 #ifndef _LIBCPP_NO_RTTI
    // function target access:
-    const std::type_info& target_type() const _NOEXCEPT;
-    template <typename _T> _T* target() _NOEXCEPT;
-    template <typename _T> const _T* target() const _NOEXCEPT;
+    const std::type_info& target_type() const;
+    template <typename _T> _T* target();
+    template <typename _T> const _T* target() const;
 #endif  // _LIBCPP_NO_RTTI
 };

@@ -1216,7 +1207,7 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
 }

 template<class _R, class ..._ArgTypes>
-function<_R(_ArgTypes...)>::function(function&& __f) _NOEXCEPT
+function<_R(_ArgTypes...)>::function(function&& __f)
 {
    if (__f.__f_ == 0)
        __f_ = 0;
@@ -1254,16 +1245,16 @@ function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc&,
 template<class _R, class ..._ArgTypes>
 template <class _F>
 function<_R(_ArgTypes...)>::function(_F __f,
-                                     typename enable_if<__callable<_F>::value>::type*)
+                                     typename enable_if<!is_integral<_F>::value>::type*)
    : __f_(0)
 {
    if (__not_null(__f))
    {
        typedef __function::__func<_F, allocator<_F>, _R(_ArgTypes...)> _FF;
-        if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
+        if (sizeof(_FF) <= sizeof(__buf_))
        {
            __f_ = (__base*)&__buf_;
-            ::new (__f_) _FF(_VSTD::move(__f));
+            ::new (__f_) _FF(_STD::move(__f));
        }
        else
        {
@@ -1271,7 +1262,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(_VSTD::move(__f), allocator<_F>(__a));
+            ::new (__hold.get()) _FF(_STD::move(__f), allocator<_F>(__a));
            __f_ = __hold.release();
        }
    }
@@ -1280,17 +1271,17 @@ function<_R(_ArgTypes...)>::function(_F __f,
 template<class _R, class ..._ArgTypes>
 template <class _F, class _Alloc>
 function<_R(_ArgTypes...)>::function(allocator_arg_t, const _Alloc& __a0, _F __f,
-                                     typename enable_if<__callable<_F>::value>::type*)
+                                     typename enable_if<!is_integral<_F>::value>::type*)
    : __f_(0)
 {
    typedef allocator_traits<_Alloc> __alloc_traits;
    if (__not_null(__f))
    {
        typedef __function::__func<_F, _Alloc, _R(_ArgTypes...)> _FF;
-        if (sizeof(_FF) <= sizeof(__buf_) && is_nothrow_copy_constructible<_F>::value)
+        if (sizeof(_FF) <= sizeof(__buf_))
        {
            __f_ = (__base*)&__buf_;
-            ::new (__f_) _FF(_VSTD::move(__f));
+            ::new (__f_) _FF(_STD::move(__f));
        }
        else
        {
@@ -1304,7 +1295,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(_VSTD::move(__f), _Alloc(__a));
+            ::new (__hold.get()) _FF(_STD::move(__f), _Alloc(__a));
            __f_ = __hold.release();
        }
    }
@@ -1320,7 +1311,7 @@ function<_R(_ArgTypes...)>::operator=(const function& __f)

 template<class _R, class ..._ArgTypes>
 function<_R(_ArgTypes...)>&
-function<_R(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT
+function<_R(_ArgTypes...)>::operator=(function&& __f)
 {
    if (__f_ == (__base*)&__buf_)
        __f_->destroy();
@@ -1343,7 +1334,7 @@ function<_R(_ArgTypes...)>::operator=(function&& __f) _NOEXCEPT

 template<class _R, class ..._ArgTypes>
 function<_R(_ArgTypes...)>&
-function<_R(_ArgTypes...)>::operator=(nullptr_t) _NOEXCEPT
+function<_R(_ArgTypes...)>::operator=(nullptr_t)
 {
    if (__f_ == (__base*)&__buf_)
        __f_->destroy();
@@ -1356,12 +1347,12 @@ template<class _R, class ..._ArgTypes>
 template <class _F>
 typename enable_if
 <
-    function<_R(_ArgTypes...)>::template __callable<typename decay<_F>::type>::value,
+    !is_integral<typename decay<_F>::type>::value,
    function<_R(_ArgTypes...)>&
 >::type
 function<_R(_ArgTypes...)>::operator=(_F&& __f)
 {
-    function(_VSTD::forward<_F>(__f)).swap(*this);
+    function(_STD::forward<_F>(__f)).swap(*this);
    return *this;
 }

@@ -1376,7 +1367,7 @@ function<_R(_ArgTypes...)>::~function()

 template<class _R, class ..._ArgTypes>
 void
-function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
+function<_R(_ArgTypes...)>::swap(function& __f)
 {
    if (__f_ == (__base*)&__buf_ && __f.__f_ == (__base*)&__f.__buf_)
    {
@@ -1408,7 +1399,7 @@ function<_R(_ArgTypes...)>::swap(function& __f) _NOEXCEPT
        __f_ = (__base*)&__buf_;
    }
    else
-        _VSTD::swap(__f_, __f.__f_);
+        _STD::swap(__f_, __f.__f_);
 }

 template<class _R, class ..._ArgTypes>
@@ -1419,14 +1410,14 @@ function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
    if (__f_ == 0)
        throw bad_function_call();
 #endif  // _LIBCPP_NO_EXCEPTIONS
-    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
+    return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
 }

 #ifndef _LIBCPP_NO_RTTI

 template<class _R, class ..._ArgTypes>
 const std::type_info&
-function<_R(_ArgTypes...)>::target_type() const _NOEXCEPT
+function<_R(_ArgTypes...)>::target_type() const
 {
    if (__f_ == 0)
        return typeid(void);
@@ -1436,7 +1427,7 @@ function<_R(_ArgTypes...)>::target_type() const _NOEXCEPT
 template<class _R, class ..._ArgTypes>
 template <typename _T>
 _T*
-function<_R(_ArgTypes...)>::target() _NOEXCEPT
+function<_R(_ArgTypes...)>::target()
 {
    if (__f_ == 0)
        return (_T*)0;
@@ -1446,7 +1437,7 @@ function<_R(_ArgTypes...)>::target() _NOEXCEPT
 template<class _R, class ..._ArgTypes>
 template <typename _T>
 const _T*
-function<_R(_ArgTypes...)>::target() const _NOEXCEPT
+function<_R(_ArgTypes...)>::target() const
 {
    if (__f_ == 0)
        return (const _T*)0;
@@ -1458,27 +1449,27 @@ function<_R(_ArgTypes...)>::target() const _NOEXCEPT
 template <class _R, class... _ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const function<_R(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return !__f;}
+operator==(const function<_R(_ArgTypes...)>& __f, nullptr_t) {return !__f;}

 template <class _R, class... _ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(nullptr_t, const function<_R(_ArgTypes...)>& __f) _NOEXCEPT {return !__f;}
+operator==(nullptr_t, const function<_R(_ArgTypes...)>& __f) {return !__f;}

 template <class _R, class... _ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const function<_R(_ArgTypes...)>& __f, nullptr_t) _NOEXCEPT {return (bool)__f;}
+operator!=(const function<_R(_ArgTypes...)>& __f, nullptr_t) {return (bool)__f;}

 template <class _R, class... _ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(nullptr_t, const function<_R(_ArgTypes...)>& __f) _NOEXCEPT {return (bool)__f;}
+operator!=(nullptr_t, const function<_R(_ArgTypes...)>& __f) {return (bool)__f;}

 template <class _R, class... _ArgTypes>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(function<_R(_ArgTypes...)>& __x, function<_R(_ArgTypes...)>& __y) _NOEXCEPT
+swap(function<_R(_ArgTypes...)>& __x, function<_R(_ArgTypes...)>& __y)
 {return __x.swap(__y);}

 template<class _Tp> struct __is_bind_expression : public false_type {};
@@ -1524,7 +1515,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename __invoke_of<_Ti&, _Uj...>::type
 __mu_expand(_Ti& __ti, tuple<_Uj...>& __uj, __tuple_indices<_Indx...>)
 {
-    return __ti(_VSTD::forward<_Uj>(get<_Indx>(__uj))...);
+    return __ti(_STD::forward<_Uj>(get<_Indx>(__uj))...);
 }

 template <class _Ti, class ..._Uj>
@@ -1559,7 +1550,7 @@ typename enable_if
 __mu(_Ti&, _Uj& __uj)
 {
    const size_t _Indx = is_placeholder<_Ti>::value - 1;
-    return _VSTD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
 }

 template <class _Ti, class _Uj>
@@ -1666,41 +1657,16 @@ 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_(_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
+        : __f_(_STD::move(__b.__f_)),
+          __bound_args_(_STD::move(__b.__bound_args_)) {}

    template <class _G, class ..._BA>
      _LIBCPP_INLINE_VISIBILITY
      explicit __bind(_G&& __f, _BA&& ...__bound_args)
-        : __f_(_VSTD::forward<_G>(__f)),
-          __bound_args_(_VSTD::forward<_BA>(__bound_args)...) {}
+        : __f_(_STD::forward<_G>(__f)),
+          __bound_args_(_STD::forward<_BA>(__bound_args)...) {}

    template <class ..._Args>
        _LIBCPP_INLINE_VISIBILITY
@@ -1708,7 +1674,7 @@ public:
        operator()(_Args&& ...__args)
        {
            return __apply_functor(__f_, __bound_args_, __indices(),
-                                  tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
+                                  tuple<_Args&&...>(_STD::forward<_Args>(__args)...));
        }

    template <class ..._Args>
@@ -1717,7 +1683,7 @@ public:
        operator()(_Args&& ...__args) const
        {
            return __apply_functor(__f_, __bound_args_, __indices(),
-                                   tuple<_Args&&...>(_VSTD::forward<_Args>(__args)...));
+                                   tuple<_Args&&...>(_STD::forward<_Args>(__args)...));
        }
 };

@@ -1732,44 +1698,22 @@ 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(_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
+        : base(_STD::forward<base>(__b)) {}

    template <class _G, class ..._BA>
      _LIBCPP_INLINE_VISIBILITY
      explicit __bind_r(_G&& __f, _BA&& ...__bound_args)
-        : base(_VSTD::forward<_G>(__f),
-               _VSTD::forward<_BA>(__bound_args)...) {}
+        : base(_STD::forward<_G>(__f),
+               _STD::forward<_BA>(__bound_args)...) {}

    template <class ..._Args>
        _LIBCPP_INLINE_VISIBILITY
        result_type
        operator()(_Args&& ...__args)
        {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            return base::operator()(_STD::forward<_Args>(__args)...);
        }

    template <class ..._Args>
@@ -1777,7 +1721,7 @@ public:
        result_type
        operator()(_Args&& ...__args) const
        {
-            return base::operator()(_VSTD::forward<_Args>(__args)...);
+            return base::operator()(_STD::forward<_Args>(__args)...);
        }
 };

@@ -1790,7 +1734,7 @@ __bind<_F, _BoundArgs...>
 bind(_F&& __f, _BoundArgs&&... __bound_args)
 {
    typedef __bind<_F, _BoundArgs...> type;
-    return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
+    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
 }

 template<class _R, class _F, class ..._BoundArgs>
@@ -1799,7 +1743,7 @@ __bind_r<_R, _F, _BoundArgs...>
 bind(_F&& __f, _BoundArgs&&... __bound_args)
 {
    typedef __bind_r<_R, _F, _BoundArgs...> type;
-    return type(_VSTD::forward<_F>(__f), _VSTD::forward<_BoundArgs>(__bound_args)...);
+    return type(_STD::forward<_F>(__f), _STD::forward<_BoundArgs>(__bound_args)...);
 }

 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -1809,7 +1753,7 @@ struct _LIBCPP_VISIBLE hash<bool>
    : public unary_function<bool, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(bool __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(bool __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1817,7 +1761,7 @@ struct _LIBCPP_VISIBLE hash<char>
    : public unary_function<char, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(char __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1825,7 +1769,7 @@ struct _LIBCPP_VISIBLE hash<signed char>
    : public unary_function<signed char, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(signed char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(signed char __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1833,7 +1777,7 @@ struct _LIBCPP_VISIBLE hash<unsigned char>
    : public unary_function<unsigned char, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned char __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(unsigned char __v) const {return static_cast<size_t>(__v);}
 };

 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS
@@ -1843,7 +1787,7 @@ struct _LIBCPP_VISIBLE hash<char16_t>
    : public unary_function<char16_t, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char16_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(char16_t __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1851,7 +1795,7 @@ struct _LIBCPP_VISIBLE hash<char32_t>
    : public unary_function<char32_t, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(char32_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(char32_t __v) const {return static_cast<size_t>(__v);}
 };

 #endif  // _LIBCPP_HAS_NO_UNICODE_CHARS
@@ -1861,7 +1805,7 @@ struct _LIBCPP_VISIBLE hash<wchar_t>
    : public unary_function<wchar_t, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(wchar_t __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(wchar_t __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1869,7 +1813,7 @@ struct _LIBCPP_VISIBLE hash<short>
    : public unary_function<short, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(short __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1877,7 +1821,7 @@ struct _LIBCPP_VISIBLE hash<unsigned short>
    : public unary_function<unsigned short, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned short __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(unsigned short __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1885,7 +1829,7 @@ struct _LIBCPP_VISIBLE hash<int>
    : public unary_function<int, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(int __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1893,7 +1837,7 @@ struct _LIBCPP_VISIBLE hash<unsigned int>
    : public unary_function<unsigned int, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned int __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(unsigned int __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1901,7 +1845,7 @@ struct _LIBCPP_VISIBLE hash<long>
    : public unary_function<long, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(long __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1909,7 +1853,7 @@ struct _LIBCPP_VISIBLE hash<unsigned long>
    : public unary_function<unsigned long, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned long __v) const _NOEXCEPT {return static_cast<size_t>(__v);}
+    size_t operator()(unsigned long __v) const {return static_cast<size_t>(__v);}
 };

 template <>
@@ -1917,7 +1861,7 @@ struct _LIBCPP_VISIBLE hash<long long>
    : public unary_function<long long, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(long long __v) const _NOEXCEPT
+    size_t operator()(long long __v) const
    {
        size_t __r = 0;
        const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
@@ -1932,7 +1876,7 @@ struct _LIBCPP_VISIBLE hash<unsigned long long>
    : public unary_function<unsigned long long, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(unsigned long long __v) const _NOEXCEPT
+    size_t operator()(unsigned long long __v) const
    {
        size_t __r = 0;
        const size_t* const __p = reinterpret_cast<const size_t*>(&__v);
@@ -1947,7 +1891,7 @@ struct _LIBCPP_VISIBLE hash<float>
    : public unary_function<float, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(float __v) const _NOEXCEPT
+    size_t operator()(float __v) const
    {
        if (__v == 0)
            return 0;
@@ -1961,7 +1905,7 @@ struct _LIBCPP_VISIBLE hash<double>
    : public unary_function<double, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(double __v) const _NOEXCEPT
+    size_t operator()(double __v) const
    {
        if (__v == 0)
            return 0;
@@ -1978,7 +1922,7 @@ struct _LIBCPP_VISIBLE hash<long double>
    : public unary_function<long double, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(long double __v) const _NOEXCEPT
+    size_t operator()(long double __v) const
    {
        if (__v == 0)
            return 0;
--- a/include/future
+++ b/include/future
@@ -452,8 +452,6 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    const error_code& code() const throw() {return __ec_;}
-
-    virtual ~future_error() _NOEXCEPT;
 };

 class __assoc_sub_state
@@ -465,7 +463,7 @@ protected:
    mutable condition_variable __cv_;
    unsigned __state_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
    void __sub_wait(unique_lock<mutex>& __lk);
 public:
    enum
@@ -545,7 +543,7 @@ class __assoc_state
 protected:
    _U __value_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:

    template <class _Arg>
@@ -568,7 +566,7 @@ public:

 template <class _R>
 void
-__assoc_state<_R>::__on_zero_shared() _NOEXCEPT
+__assoc_state<_R>::__on_zero_shared()
 {
    if (this->__state_ & base::__constructed)
        reinterpret_cast<_R*>(&__value_)->~_R();
@@ -585,11 +583,9 @@ __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));
-#endif
-    ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
+    ::new(&__value_) _R(_STD::forward<_Arg>(__arg));
    this->__state_ |= base::__constructed | base::ready;
    __lk.unlock();
    __cv_.notify_all();
@@ -605,11 +601,9 @@ __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));
-#endif
-    ::new(&__value_) _R(_VSTD::forward<_Arg>(__arg));
+    ::new(&__value_) _R(_STD::forward<_Arg>(__arg));
    this->__state_ |= base::__constructed;
    __thread_local_data()->__make_ready_at_thread_exit(this);
    __lk.unlock();
@@ -623,7 +617,7 @@ __assoc_state<_R>::move()
    this->__sub_wait(__lk);
    if (this->__exception_ != nullptr)
        rethrow_exception(this->__exception_);
-    return _VSTD::move(*reinterpret_cast<_R*>(&__value_));
+    return _STD::move(*reinterpret_cast<_R*>(&__value_));
 }

 template <class _R>
@@ -646,7 +640,7 @@ class __assoc_state<_R&>
 protected:
    _U __value_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:

    void set_value(_R& __arg);
@@ -657,7 +651,7 @@ public:

 template <class _R>
 void
-__assoc_state<_R&>::__on_zero_shared() _NOEXCEPT
+__assoc_state<_R&>::__on_zero_shared()
 {
    delete this;
 }
@@ -667,10 +661,8 @@ 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();
@@ -682,10 +674,8 @@ 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);
@@ -710,7 +700,7 @@ class __assoc_state_alloc
    typedef __assoc_state<_R> base;
    _Alloc __alloc_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:
    _LIBCPP_INLINE_VISIBILITY
    explicit __assoc_state_alloc(const _Alloc& __a)
@@ -719,7 +709,7 @@ public:

 template <class _R, class _Alloc>
 void
-__assoc_state_alloc<_R, _Alloc>::__on_zero_shared() _NOEXCEPT
+__assoc_state_alloc<_R, _Alloc>::__on_zero_shared()
 {
    if (this->__state_ & base::__constructed)
        reinterpret_cast<_R*>(&this->__value_)->~_R();
@@ -735,7 +725,7 @@ class __assoc_state_alloc<_R&, _Alloc>
    typedef __assoc_state<_R&> base;
    _Alloc __alloc_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:
    _LIBCPP_INLINE_VISIBILITY
    explicit __assoc_state_alloc(const _Alloc& __a)
@@ -744,7 +734,7 @@ public:

 template <class _R, class _Alloc>
 void
-__assoc_state_alloc<_R&, _Alloc>::__on_zero_shared() _NOEXCEPT
+__assoc_state_alloc<_R&, _Alloc>::__on_zero_shared()
 {
    typename _Alloc::template rebind<__assoc_state_alloc>::other __a(__alloc_);
    this->~__assoc_state_alloc();
@@ -758,7 +748,7 @@ class __assoc_sub_state_alloc
    typedef __assoc_sub_state base;
    _Alloc __alloc_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:
    _LIBCPP_INLINE_VISIBILITY
    explicit __assoc_sub_state_alloc(const _Alloc& __a)
@@ -767,7 +757,7 @@ public:

 template <class _Alloc>
 void
-__assoc_sub_state_alloc<_Alloc>::__on_zero_shared() _NOEXCEPT
+__assoc_sub_state_alloc<_Alloc>::__on_zero_shared()
 {
    this->~base();
    typename _Alloc::template rebind<__assoc_sub_state_alloc>::other __a(__alloc_);
@@ -796,7 +786,7 @@ public:
 template <class _R, class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __deferred_assoc_state<_R, _F>::__deferred_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+    : __func_(_STD::forward<_F>(__f))
 {
    this->__set_deferred();
 }
@@ -842,7 +832,7 @@ public:
 template <class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __deferred_assoc_state<void, _F>::__deferred_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+    : __func_(_STD::forward<_F>(__f))
 {
    this->__set_deferred();
 }
@@ -876,7 +866,7 @@ class __async_assoc_state

    _F __func_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    explicit __async_assoc_state(_F&& __f);
@@ -890,7 +880,7 @@ public:
 template <class _R, class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __async_assoc_state<_R, _F>::__async_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+    : __func_(_STD::forward<_F>(__f))
 {
 }

@@ -916,7 +906,7 @@ __async_assoc_state<_R, _F>::__execute()

 template <class _R, class _F>
 void
-__async_assoc_state<_R, _F>::__on_zero_shared() _NOEXCEPT
+__async_assoc_state<_R, _F>::__on_zero_shared()
 {
    this->wait();
    base::__on_zero_shared();
@@ -930,7 +920,7 @@ class __async_assoc_state<void, _F>

    _F __func_;

-    virtual void __on_zero_shared() _NOEXCEPT;
+    virtual void __on_zero_shared();
 public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    explicit __async_assoc_state(_F&& __f);
@@ -944,7 +934,7 @@ public:
 template <class _F>
 inline _LIBCPP_INLINE_VISIBILITY
 __async_assoc_state<void, _F>::__async_assoc_state(_F&& __f)
-    : __func_(_VSTD::forward<_F>(__f))
+    : __func_(_STD::forward<_F>(__f))
 {
 }

@@ -971,14 +961,15 @@ __async_assoc_state<void, _F>::__execute()

 template <class _F>
 void
-__async_assoc_state<void, _F>::__on_zero_shared() _NOEXCEPT
+__async_assoc_state<void, _F>::__on_zero_shared()
 {
    this->wait();
    base::__on_zero_shared();
 }

-template <class _R> class promise;
-template <class _R> class shared_future;
+template <class> class promise;
+template <class> class shared_future;
+template <class> class atomic_future;

 // future

@@ -1009,6 +1000,7 @@ 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>
@@ -1050,7 +1042,7 @@ public:
    _R get();

    _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // functions to check state
    _LIBCPP_INLINE_VISIBILITY
@@ -1074,10 +1066,8 @@ 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();
 }
@@ -1113,6 +1103,7 @@ 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>
@@ -1154,7 +1145,7 @@ public:
    _R& get();

    _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // functions to check state
    _LIBCPP_INLINE_VISIBILITY
@@ -1178,10 +1169,8 @@ 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();
 }
@@ -1212,6 +1201,7 @@ 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>
@@ -1253,7 +1243,7 @@ public:
    void get();

    _LIBCPP_INLINE_VISIBILITY
-    void swap(future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // functions to check state
    _LIBCPP_INLINE_VISIBILITY
@@ -1283,7 +1273,7 @@ swap(future<_R>& __x, future<_R>& __y)

 // promise<R>

-template <class _Callable> class packaged_task;
+template <class> class packaged_task;

 template <class _R>
 class _LIBCPP_VISIBLE promise
@@ -1325,7 +1315,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // retrieving the result
    future<_R> get_future();
@@ -1380,10 +1370,8 @@ 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_);
 }

@@ -1391,10 +1379,8 @@ 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);
 }

@@ -1404,11 +1390,9 @@ 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(_VSTD::move(__r));
+    __state_->set_value(_STD::move(__r));
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1417,10 +1401,8 @@ 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);
 }

@@ -1428,10 +1410,8 @@ 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);
 }

@@ -1441,11 +1421,9 @@ 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(_VSTD::move(__r));
+    __state_->set_value_at_thread_exit(_STD::move(__r));
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -1454,10 +1432,8 @@ 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);
 }

@@ -1504,7 +1480,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // retrieving the result
    future<_R&> get_future();
@@ -1553,10 +1529,8 @@ 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_);
 }

@@ -1564,10 +1538,8 @@ 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);
 }

@@ -1575,10 +1547,8 @@ 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);
 }

@@ -1586,10 +1556,8 @@ 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);
 }

@@ -1597,10 +1565,8 @@ 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);
 }

@@ -1647,7 +1613,7 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
-    void swap(promise& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(promise& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // retrieving the result
    future<void> get_future();
@@ -1717,13 +1683,13 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    explicit __packaged_task_func(const _F& __f) : __f_(__f) {}
    _LIBCPP_INLINE_VISIBILITY
-    explicit __packaged_task_func(_F&& __f) : __f_(_VSTD::move(__f)) {}
+    explicit __packaged_task_func(_F&& __f) : __f_(_STD::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_(_VSTD::move(__f), __a) {}
+        : __f_(_STD::move(__f), __a) {}
    virtual void __move_to(__packaged_task_base<_R(_ArgTypes...)>*);
    virtual void destroy();
    virtual void destroy_deallocate();
@@ -1735,7 +1701,7 @@ void
 __packaged_task_func<_F, _Alloc, _R(_ArgTypes...)>::__move_to(
                              __packaged_task_base<_R(_ArgTypes...)>* __p)
 {
-    ::new (__p) __packaged_task_func(_VSTD::move(__f_.first()), _VSTD::move(__f_.second()));
+    ::new (__p) __packaged_task_func(_STD::move(__f_.first()), _STD::move(__f_.second()));
 }

 template<class _F, class _Alloc, class _R, class ..._ArgTypes>
@@ -1759,10 +1725,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(), _VSTD::forward<_ArgTypes>(__arg)...);
+    return __invoke(__f_.first(), _STD::forward<_ArgTypes>(__arg)...);
 }

-template <class _Callable> class __packaged_task_function;
+template <class> class __packaged_task_function;

 template<class _R, class ..._ArgTypes>
 class __packaged_task_function<_R(_ArgTypes...)>
@@ -1822,7 +1788,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(_F&& __f)
    if (sizeof(_FF) <= sizeof(__buf_))
    {
        __f_ = (__base*)&__buf_;
-        ::new (__f_) _FF(_VSTD::forward<_F>(__f));
+        ::new (__f_) _FF(_STD::forward<_F>(__f));
    }
    else
    {
@@ -1830,7 +1796,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(_VSTD::forward<_F>(__f), allocator<_FR>(__a));
+        ::new (__hold.get()) _FF(_STD::forward<_F>(__f), allocator<_FR>(__a));
        __f_ = __hold.release();
    }
 }
@@ -1847,7 +1813,7 @@ __packaged_task_function<_R(_ArgTypes...)>::__packaged_task_function(
    if (sizeof(_FF) <= sizeof(__buf_))
    {
        __f_ = (__base*)&__buf_;
-        ::new (__f_) _FF(_VSTD::forward<_F>(__f));
+        ::new (__f_) _FF(_STD::forward<_F>(__f));
    }
    else
    {
@@ -1861,7 +1827,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(_VSTD::forward<_F>(__f), _Alloc(__a));
+        ::new (__hold.get()) _FF(_STD::forward<_F>(__f), _Alloc(__a));
        __f_ = __hold.release();
    }
 }
@@ -1932,7 +1898,7 @@ __packaged_task_function<_R(_ArgTypes...)>::swap(__packaged_task_function& __f)
        __f_ = (__base*)&__buf_;
    }
    else
-        _VSTD::swap(__f_, __f.__f_);
+        _STD::swap(__f_, __f.__f_);
 }

 template<class _R, class ..._ArgTypes>
@@ -1940,7 +1906,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 _R
 __packaged_task_function<_R(_ArgTypes...)>::operator()(_ArgTypes... __arg) const
 {
-    return (*__f_)(_VSTD::forward<_ArgTypes>(__arg)...);
+    return (*__f_)(_STD::forward<_ArgTypes>(__arg)...);
 }

 template<class _R, class ..._ArgTypes>
@@ -1959,11 +1925,11 @@ public:
    packaged_task() : __p_(nullptr) {}
    template <class _F>
        _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
+        explicit packaged_task(_F&& __f) : __f_(_STD::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, _VSTD::forward<_F>(__f)),
+             : __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
               __p_(allocator_arg, __a) {}
    // ~packaged_task() = default;

@@ -1974,12 +1940,12 @@ public:
    // move support
    _LIBCPP_INLINE_VISIBILITY
    packaged_task(packaged_task&& __other)
-        : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
+        : __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
    _LIBCPP_INLINE_VISIBILITY
    packaged_task& operator=(packaged_task&& __other)
    {
-        __f_ = _VSTD::move(__other.__f_);
-        __p_ = _VSTD::move(__other.__p_);
+        __f_ = _STD::move(__other.__f_);
+        __p_ = _STD::move(__other.__p_);
        return *this;
    }
    _LIBCPP_INLINE_VISIBILITY
@@ -2015,7 +1981,7 @@ packaged_task<_R(_ArgTypes...)>::operator()(_ArgTypes... __args)
    try
    {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __p_.set_value(__f_(_VSTD::forward<_ArgTypes>(__args)...));
+        __p_.set_value(__f_(_STD::forward<_ArgTypes>(__args)...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
    catch (...)
@@ -2037,7 +2003,7 @@ packaged_task<_R(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args)
    try
    {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __p_.set_value_at_thread_exit(__f_(_VSTD::forward<_ArgTypes>(__args)...));
+        __p_.set_value_at_thread_exit(__f_(_STD::forward<_ArgTypes>(__args)...));
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
    catch (...)
@@ -2074,11 +2040,11 @@ public:
    packaged_task() : __p_(nullptr) {}
    template <class _F>
        _LIBCPP_INLINE_VISIBILITY
-        explicit packaged_task(_F&& __f) : __f_(_VSTD::forward<_F>(__f)) {}
+        explicit packaged_task(_F&& __f) : __f_(_STD::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, _VSTD::forward<_F>(__f)),
+             : __f_(allocator_arg, __a, _STD::forward<_F>(__f)),
               __p_(allocator_arg, __a) {}
    // ~packaged_task() = default;

@@ -2089,12 +2055,12 @@ public:
    // move support
    _LIBCPP_INLINE_VISIBILITY
    packaged_task(packaged_task&& __other)
-        : __f_(_VSTD::move(__other.__f_)), __p_(_VSTD::move(__other.__p_)) {}
+        : __f_(_STD::move(__other.__f_)), __p_(_STD::move(__other.__p_)) {}
    _LIBCPP_INLINE_VISIBILITY
    packaged_task& operator=(packaged_task&& __other)
    {
-        __f_ = _VSTD::move(__other.__f_);
-        __p_ = _VSTD::move(__other.__p_);
+        __f_ = _STD::move(__other.__f_);
+        __p_ = _STD::move(__other.__p_);
        return *this;
    }
    _LIBCPP_INLINE_VISIBILITY
@@ -2130,7 +2096,7 @@ packaged_task<void(_ArgTypes...)>::operator()(_ArgTypes... __args)
    try
    {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __f_(_VSTD::forward<_ArgTypes>(__args)...);
+        __f_(_STD::forward<_ArgTypes>(__args)...);
        __p_.set_value();
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -2153,7 +2119,7 @@ packaged_task<void(_ArgTypes...)>::make_ready_at_thread_exit(_ArgTypes... __args
    try
    {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-        __f_(_VSTD::forward<_ArgTypes>(__args)...);
+        __f_(_STD::forward<_ArgTypes>(__args)...);
        __p_.set_value_at_thread_exit();
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -2196,7 +2162,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>(_VSTD::forward<_F>(__f)));
+        __h(new __deferred_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
    return future<_R>(__h.get());
 }

@@ -2209,8 +2175,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>(_VSTD::forward<_F>(__f)));
-    _VSTD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
+        __h(new __async_assoc_state<_R, _F>(_STD::forward<_F>(__f)));
+    _STD::thread(&__async_assoc_state<_R, _F>::__execute, __h.get()).detach();
    return future<_R>(__h.get());
 }

@@ -2224,10 +2190,10 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    explicit __async_func(_F&& __f, _Args&&... __args)
-        : __f_(_VSTD::move(__f), _VSTD::move(__args)...) {}
+        : __f_(_STD::move(__f), _STD::move(__args)...) {}

    _LIBCPP_INLINE_VISIBILITY
-    __async_func(__async_func&& __f) : __f_(_VSTD::move(__f.__f_)) {}
+    __async_func(__async_func&& __f) : __f_(_STD::move(__f.__f_)) {}

    _R operator()()
    {
@@ -2239,7 +2205,7 @@ private:
    _R
    __execute(__tuple_indices<_Indices...>)
    {
-        return __invoke(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
+        return __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::get<_Indices>(__f_))...);
    }
 };

@@ -2251,11 +2217,11 @@ async(launch __policy, _F&& __f, _Args&&... __args)
    typedef typename _BF::_R _R;
    future<_R> __r;
    if (__policy & launch::async)
-        __r = _VSTD::__make_async_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
-                                                     __decay_copy(_VSTD::forward<_Args>(__args))...));
+        __r = _STD::__make_async_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)),
+                                                     __decay_copy(_STD::forward<_Args>(__args))...));
    else if (__policy & launch::deferred)
-        __r = _VSTD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_VSTD::forward<_F>(__f)),
-                                                        __decay_copy(_VSTD::forward<_Args>(__args))...));
+        __r = _STD::__make_deferred_assoc_state<_R>(_BF(__decay_copy(_STD::forward<_F>(__f)),
+                                                        __decay_copy(_STD::forward<_Args>(__args))...));
    return __r;
 }

@@ -2264,8 +2230,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 future<typename __invoke_of<typename decay<_F>::type, typename decay<_Args>::type...>::type>
 async(_F&& __f, _Args&&... __args)
 {
-    return _VSTD::async(launch::any, _VSTD::forward<_F>(__f),
-                                    _VSTD::forward<_Args>(__args)...);
+    return _STD::async(launch::any, _STD::forward<_F>(__f),
+                                    _STD::forward<_Args>(__args)...);
 }

 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -2307,7 +2273,7 @@ public:
    const _R& get() const {return __state_->copy();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // functions to check state
    _LIBCPP_INLINE_VISIBILITY
@@ -2381,7 +2347,7 @@ public:
    _R& get() const {return __state_->copy();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // functions to check state
    _LIBCPP_INLINE_VISIBILITY
@@ -2455,7 +2421,7 @@ public:
    void get() const {__state_->copy();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(shared_future& __rhs) {_VSTD::swap(__state_, __rhs.__state_);}
+    void swap(shared_future& __rhs) {_STD::swap(__state_, __rhs.__state_);}

    // functions to check state
    _LIBCPP_INLINE_VISIBILITY
@@ -2488,7 +2454,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_future<_R>
 future<_R>::share()
 {
-    return shared_future<_R>(_VSTD::move(*this));
+    return shared_future<_R>(_STD::move(*this));
 }

 template <class _R>
@@ -2496,7 +2462,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_future<_R&>
 future<_R&>::share()
 {
-    return shared_future<_R&>(_VSTD::move(*this));
+    return shared_future<_R&>(_STD::move(*this));
 }

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -2505,7 +2471,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 shared_future<void>
 future<void>::share()
 {
-    return shared_future<void>(_VSTD::move(*this));
+    return shared_future<void>(_STD::move(*this));
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
--- a/include/initializer_list
+++ b/include/initializer_list
@@ -29,15 +29,15 @@ public:
    typedef const E* iterator;
    typedef const E* const_iterator;

-    initializer_list() noexcept;
+    initializer_list();

-    size_t   size()  const noexcept;
-    const E* begin() const noexcept;
-    const E* end()   const noexcept;
+    size_t   size()  const;
+    const E* begin() const;
+    const E* end()   const;
 };

-template<class E> const E* begin(initializer_list<E> il) noexcept;
-template<class E> const E* end(initializer_list<E> il) noexcept;
+template<class E> const E* begin(initializer_list<E> il);
+template<class E> const E* end(initializer_list<E> il);

 }  // std

@@ -51,8 +51,6 @@ template<class E> const E* end(initializer_list<E> il) noexcept;
 namespace std  // purposefully not versioned
 {

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template<class _E>
 class _LIBCPP_VISIBLE initializer_list
 {
@@ -60,7 +58,7 @@ class _LIBCPP_VISIBLE initializer_list
    size_t    __size_;

    _LIBCPP_ALWAYS_INLINE
-    initializer_list(const _E* __b, size_t __s) _NOEXCEPT
+    initializer_list(const _E* __b, size_t __s)
        : __begin_(__b),
          __size_(__s)
        {}
@@ -73,17 +71,17 @@ public:
    typedef const _E* iterator;
    typedef const _E* const_iterator;

-    _LIBCPP_ALWAYS_INLINE initializer_list() _NOEXCEPT : __begin_(nullptr), __size_(0) {}
+    _LIBCPP_ALWAYS_INLINE initializer_list() : __begin_(nullptr), __size_(0) {}

-    _LIBCPP_ALWAYS_INLINE size_t    size()  const _NOEXCEPT {return __size_;}
-    _LIBCPP_ALWAYS_INLINE const _E* begin() const _NOEXCEPT {return __begin_;}
-    _LIBCPP_ALWAYS_INLINE const _E* end()   const _NOEXCEPT {return __begin_ + __size_;}
+    _LIBCPP_ALWAYS_INLINE size_t    size()  const {return __size_;}
+    _LIBCPP_ALWAYS_INLINE const _E* begin() const {return __begin_;}
+    _LIBCPP_ALWAYS_INLINE const _E* end()   const {return __begin_ + __size_;}
 };

 template<class _E>
 inline _LIBCPP_INLINE_VISIBILITY
 const _E*
-begin(initializer_list<_E> __il) _NOEXCEPT
+begin(initializer_list<_E> __il)
 {
    return __il.begin();
 }
@@ -91,13 +89,11 @@ begin(initializer_list<_E> __il) _NOEXCEPT
 template<class _E>
 inline _LIBCPP_INLINE_VISIBILITY
 const _E*
-end(initializer_list<_E> __il) _NOEXCEPT
+end(initializer_list<_E> __il)
 {
    return __il.end();
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 }  // std

 #endif  // _LIBCPP_INITIALIZER_LIST
--- a/include/ios
+++ b/include/ios
@@ -266,8 +266,8 @@ public:
    enum seekdir {beg, cur, end};
    typedef seekdir seek_dir;

-    typedef _VSTD::streamoff streamoff;
-    typedef _VSTD::streampos streampos;
+    typedef _STD::streamoff streamoff;
+    typedef _STD::streampos streampos;

    class Init;

@@ -776,8 +776,8 @@ void
 basic_ios<_CharT, _Traits>::swap(basic_ios& __rhs)
 {
    ios_base::swap(__rhs);
-    _VSTD::swap(__tie_, __rhs.__tie_);
-    _VSTD::swap(__fill_, __rhs.__fill_);
+    _STD::swap(__tie_, __rhs.__tie_);
+    _STD::swap(__fill_, __rhs.__fill_);
 }

 template <class _CharT, class _Traits>
--- a/include/istream
+++ b/include/istream
@@ -177,13 +177,11 @@ 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);
@@ -323,7 +321,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 basic_istream<_CharT, _Traits>::swap(basic_istream& __rhs)
 {
-    _VSTD::swap(__gc_, __rhs.__gc_);
+    _STD::swap(__gc_, __rhs.__gc_);
    basic_ios<char_type, traits_type>::swap(__rhs);
 }

@@ -742,29 +740,26 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT* __s)
        typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
        if (__sen)
        {
+            typedef istreambuf_iterator<_CharT, _Traits> _I;
            streamsize __n = __is.width();
-            if (__n <= 0)
+            if (__n == 0)
                __n = numeric_limits<streamsize>::max() / sizeof(_CharT) - 1;
            streamsize __c = 0;
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
-            ios_base::iostate __err = ios_base::goodbit;
-            while (__c < __n-1)
+            _I __i(__is);
+            _I __eof;
+            for (; __i != __eof && __c < __n-1; ++__i, ++__s, ++__c)
            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __err |= ios_base::eofbit;
-                   break;
-                }
-                _CharT __ch = _Traits::to_char_type(__i);
+                _CharT __ch = *__i;
                if (__ct.is(__ct.space, __ch))
                    break;
-                *__s++ = __ch;
-                ++__c;
-                 __is.rdbuf()->sbumpc();
+                *__s = __ch;
            }
            *__s = _CharT();
            __is.width(0);
+            ios_base::iostate __err = ios_base::goodbit;
+            if (__i == __eof)
+               __err |= ios_base::eofbit;
            if (__c == 0)
               __err |= ios_base::failbit;
            __is.setstate(__err);
@@ -806,11 +801,25 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
        typename basic_istream<_CharT, _Traits>::sentry __sen(__is);
        if (__sen)
        {
+#if 1
            typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
            if (_Traits::eq_int_type(__i, _Traits::eof()))
                __is.setstate(ios_base::eofbit | ios_base::failbit);
            else
                __c = _Traits::to_char_type(__i);
+#else
+            typedef istreambuf_iterator<_CharT, _Traits> _I;
+            _I __i(__is);
+            _I __eof;
+            if (__i != __eof)
+            {
+                __c = *__i;
+                if (++__i == __eof)
+                    __is.setstate(ios_base::eofbit);
+            }
+            else
+                __is.setstate(ios_base::eofbit | ios_base::failbit);
+#endif
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -850,42 +859,42 @@ basic_istream<_CharT, _Traits>::operator>>(basic_streambuf<char_type, traits_typ
        sentry __s(*this, true);
        if (__s)
        {
+            streamsize __c = 0;
            if (__sb)
            {
 #ifndef _LIBCPP_NO_EXCEPTIONS
                try
                {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-                    ios_base::iostate __err = ios_base::goodbit;
-                    while (true)
+                    typedef istreambuf_iterator<char_type, traits_type> _I;
+                    typedef ostreambuf_iterator<char_type, traits_type> _O;
+                    _I __i(*this);
+                    _I __eof;
+                    _O __o(__sb);
+                    for (; __i != __eof; ++__i, ++__o, ++__c)
                    {
-                        typename traits_type::int_type __i = this->rdbuf()->sgetc();
-                        if (traits_type::eq_int_type(__i, _Traits::eof()))
-                        {
-                           __err |= ios_base::eofbit;
-                           break;
-                        }
-                        if (traits_type::eq_int_type(
-                                __sb->sputc(traits_type::to_char_type(__i)),
-                                traits_type::eof()))
+                        *__o = *__i;
+                        if (__o.failed())
                            break;
-                        ++__gc_;
-                        this->rdbuf()->sbumpc();
                    }
-                    if (__gc_ == 0)
+                    ios_base::iostate __err = ios_base::goodbit;
+                    if (__i == __eof)
+                       __err |= ios_base::eofbit;
+                    if (__c == 0)
                       __err |= ios_base::failbit;
                    this->setstate(__err);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                }
                catch (...)
                {
-                    if (__gc_ == 0)
+                    if (__c == 0)
                        this->__set_failbit_and_consider_rethrow();
                }
 #endif  // _LIBCPP_NO_EXCEPTIONS
            }
            else
                this->setstate(ios_base::failbit);
+            __gc_ = __c;
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -910,11 +919,22 @@ basic_istream<_CharT, _Traits>::get()
        sentry __s(*this, true);
        if (__s)
        {
-            __r = this->rdbuf()->sbumpc();
-            if (traits_type::eq_int_type(__r, traits_type::eof()))
-               this->setstate(ios_base::failbit | ios_base::eofbit);
+            streamsize __c = 0;
+            typedef istreambuf_iterator<char_type, traits_type> _I;
+            _I __i(*this);
+            _I __eof;
+            ios_base::iostate __err = ios_base::goodbit;
+            if (__i != __eof)
+            {
+                __r = traits_type::to_int_type(*__i);
+                ++__c;
+                if (++__i == __eof)
+                    __err |= ios_base::eofbit;
+            }
            else
-                __gc_ = 1;
+                __err |= ios_base::failbit | ios_base::eofbit;
+            this->setstate(__err);
+            __gc_ = __c;
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -949,31 +969,30 @@ basic_istream<_CharT, _Traits>::get(char_type* __s, streamsize __n, char_type __
        sentry __sen(*this, true);
        if (__sen)
        {
+            streamsize __c = 0;
            if (__n > 0)
            {
-                ios_base::iostate __err = ios_base::goodbit;
-                while (__gc_ < __n-1)
+                typedef istreambuf_iterator<char_type, traits_type> _I;
+                _I __i(*this);
+                _I __eof;
+                for (; __i != __eof && __n > 1; ++__i, ++__s, ++__c)
                {
-                    int_type __i = this->rdbuf()->sgetc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __err |= ios_base::eofbit;
-                       break;
-                    }
-                    char_type __ch = traits_type::to_char_type(__i);
+                    char_type __ch = *__i;
                    if (traits_type::eq(__ch, __dlm))
                        break;
-                    *__s++ = __ch;
-                    ++__gc_;
-                     this->rdbuf()->sbumpc();
+                    *__s = __ch;
                }
                *__s = char_type();
-                if (__gc_ == 0)
+                ios_base::iostate __err = ios_base::goodbit;
+                if (__i == __eof)
+                   __err |= ios_base::eofbit;
+                if (__c == 0)
                   __err |= ios_base::failbit;
                this->setstate(__err);
            }
            else
                this->setstate(ios_base::failbit);
+            __gc_ = __c;
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -1006,36 +1025,38 @@ basic_istream<_CharT, _Traits>::get(basic_streambuf<char_type, traits_type>& __s
        sentry __sen(*this, true);
        if (__sen)
        {
+            streamsize __c = 0;
            ios_base::iostate __err = ios_base::goodbit;
 #ifndef _LIBCPP_NO_EXCEPTIONS
            try
            {
 #endif  // _LIBCPP_NO_EXCEPTIONS
-                while (true)
+                typedef istreambuf_iterator<char_type, traits_type> _I;
+                typedef ostreambuf_iterator<char_type, traits_type> _O;
+                _I __i(*this);
+                _I __eof;
+                _O __o(&__sb);
+                for (; __i != __eof; ++__i, ++__o, ++__c)
                {
-                    typename traits_type::int_type __i = this->rdbuf()->sgetc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __err |= ios_base::eofbit;
-                       break;
-                    }
-                    char_type __ch = traits_type::to_char_type(__i);
+                    char_type __ch = *__i;
                    if (traits_type::eq(__ch, __dlm))
                        break;
-                    if (traits_type::eq_int_type(__sb.sputc(__ch), traits_type::eof()))
+                    *__o = __ch;
+                    if (__o.failed())
                        break;
-                    ++__gc_;
-                    this->rdbuf()->sbumpc();
                }
+                if (__i == __eof)
+                   __err |= ios_base::eofbit;
 #ifndef _LIBCPP_NO_EXCEPTIONS
            }
            catch (...)
            {
            }
 #endif  // _LIBCPP_NO_EXCEPTIONS
-            if (__gc_ == 0)
+            if (__c == 0)
               __err |= ios_base::failbit;
            this->setstate(__err);
+            __gc_ = __c;
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -1067,36 +1088,33 @@ basic_istream<_CharT, _Traits>::getline(char_type* __s, streamsize __n, char_typ
        sentry __sen(*this, true);
        if (__sen)
        {
-            ios_base::iostate __err = ios_base::goodbit;
-            while (true)
+            streamsize __c = 0;
+            typedef istreambuf_iterator<char_type, traits_type> _I;
+            _I __i(*this);
+            _I __eof;
+            for (; __i != __eof; ++__s, --__n)
            {
-                typename traits_type::int_type __i = this->rdbuf()->sgetc();
-                if (traits_type::eq_int_type(__i, traits_type::eof()))
-                {
-                   __err |= ios_base::eofbit;
-                   break;
-                }
-                char_type __ch = traits_type::to_char_type(__i);
+                char_type __ch = *__i;
+                ++__i;
+                ++__c;
                if (traits_type::eq(__ch, __dlm))
+                    break;
+                if (__n < 2)
                {
-                    this->rdbuf()->sbumpc();
-                    ++__gc_;
+                    this->setstate(ios_base::failbit);
                    break;
                }
-                if (__gc_ >= __n-1)
-                {
-                    __err |= ios_base::failbit;
-                    break;
-                }
-                *__s++ = __ch;
-                this->rdbuf()->sbumpc();
-                ++__gc_;
+                *__s = __ch;
            }
-            if (__n > 0)
+            if (__n)
                *__s = char_type();
-            if (__gc_ == 0)
+            ios_base::iostate __err = ios_base::goodbit;
+            if (__i == __eof)
+               __err |= ios_base::eofbit;
+            if (__c == 0)
               __err |= ios_base::failbit;
            this->setstate(__err);
+            __gc_ = __c;
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -1128,40 +1146,35 @@ basic_istream<_CharT, _Traits>::ignore(streamsize __n, int_type __dlm)
        sentry __sen(*this, true);
        if (__sen)
        {
-            ios_base::iostate __err = ios_base::goodbit;
-            if (__n == numeric_limits<streamsize>::max())
+            streamsize __c = 0;
+            typedef istreambuf_iterator<char_type, traits_type> _I;
+            _I __i(*this);
+            _I __eof;
+            if (__n != numeric_limits<streamsize>::max())
            {
-                while (true)
+                for (; __n > 0 && __i != __eof; --__n)
                {
-                    typename traits_type::int_type __i = this->rdbuf()->sbumpc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __err |= ios_base::eofbit;
-                       break;
-                    }
-                    ++__gc_;
-                    char_type __ch = traits_type::to_char_type(__i);
+                    char_type __ch = *__i;
+                    ++__i;
+                    ++__c;
                    if (traits_type::eq(__ch, __dlm))
                        break;
                }
            }
            else
            {
-                while (__gc_ < __n)
+                while (__i != __eof)
                {
-                    typename traits_type::int_type __i = this->rdbuf()->sbumpc();
-                    if (traits_type::eq_int_type(__i, traits_type::eof()))
-                    {
-                       __err |= ios_base::eofbit;
-                       break;
-                    }
-                    ++__gc_;
-                    char_type __ch = traits_type::to_char_type(__i);
+                    char_type __ch = *__i;
+                    ++__i;
+                    ++__c;
                    if (traits_type::eq(__ch, __dlm))
                        break;
                }
            }
-            this->setstate(__err);
+            if (__i == __eof)
+                this->setstate(ios_base::eofbit);
+            __gc_ = __c;
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -1208,17 +1221,20 @@ basic_istream<_CharT, _Traits>::read(char_type* __s, streamsize __n)
        sentry __sen(*this, true);
        if (__sen)
        {
-            ios_base::iostate __err = ios_base::goodbit;
-            for (; __gc_ < __n; ++__gc_)
+            streamsize __c = 0;
+            typedef istreambuf_iterator<char_type, traits_type> _I;
+            _I __i(*this);
+            _I __eof;
+            for (; __i != __eof && __n > 0; ++__i, ++__s, ++__c, --__n)
+                *__s = *__i;
+            if (__i == __eof)
            {
-                typename traits_type::int_type __i = this->rdbuf()->sbumpc();
-                if (traits_type::eq_int_type(__i, traits_type::eof()))
-                {
-                   this->setstate(ios_base::failbit | ios_base::eofbit);
-                   break;
-                }
-                *__s++ = traits_type::to_char_type(__i);
+                ios_base::iostate __err = ios_base::eofbit;
+                if (__n > 0)
+                    __err |= ios_base::failbit;
+                this->setstate(__err);
            }
+            __gc_ = __c;
        }
        else
            this->setstate(ios_base::failbit);
@@ -1236,19 +1252,45 @@ template<class _CharT, class _Traits>
 streamsize
 basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
 {
-    streamsize __c = this->rdbuf()->in_avail();
-    switch (__c)
+    __gc_ = 0;
+    streamsize __c = 0;
+#ifndef _LIBCPP_NO_EXCEPTIONS
+    try
    {
-    case -1:
-        this->setstate(ios_base::eofbit);
-        break;
-    case 0:
-        break;
-    default:
-        read(__s, _VSTD::min(__c, __n));
-        break;
+#endif  // _LIBCPP_NO_EXCEPTIONS
+        sentry __sen(*this, true);
+        if (__sen)
+        {
+            typedef istreambuf_iterator<char_type, traits_type> _I;
+            _I __i(*this);
+            _I __eof;
+            __c = this->rdbuf()->in_avail();
+            switch (__c)
+            {
+            case -1:
+                __i = __eof;
+                break;
+            case 0:
+                break;
+            default:
+                __c = _STD::min(__c, __n);
+                for (streamsize __k = 0; __k < __c; ++__k, ++__s, ++__i)
+                    *__s = *__i;
+            }
+            if (__i == __eof)
+                this->setstate(ios_base::eofbit);
+            __gc_ = __c;
+        }
+        else
+            this->setstate(ios_base::failbit);
+#ifndef _LIBCPP_NO_EXCEPTIONS
    }
-    return __gc_;
+    catch (...)
+    {
+        this->__set_badbit_and_consider_rethrow();
+    }
+#endif  // _LIBCPP_NO_EXCEPTIONS
+    return __c;
 }

 template<class _CharT, class _Traits>
@@ -1411,19 +1453,15 @@ ws(basic_istream<_CharT, _Traits>& __is)
        typename basic_istream<_CharT, _Traits>::sentry __sen(__is, true);
        if (__sen)
        {
+            typedef istreambuf_iterator<_CharT, _Traits> _I;
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
-            while (true)
-            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __is.setstate(ios_base::eofbit);
-                   break;
-                }
-                if (!__ct.is(__ct.space, _Traits::to_char_type(__i)))
+            _I __i(__is);
+            _I __eof;
+            for (; __i != __eof; ++__i)
+                if (!__ct.is(__ct.space, *__i))
                    break;
-                __is.rdbuf()->sbumpc();
-            }
+            if (__i == __eof)
+                __is.setstate(ios_base::failbit | ios_base::eofbit);
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -1466,13 +1504,11 @@ 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);
@@ -1491,7 +1527,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>(_VSTD::move(__rhs))
+    : basic_istream<_CharT, _Traits>(_STD::move(__rhs))
 {
 }

@@ -1532,30 +1568,27 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
        if (__sen)
        {
            __str.clear();
+            typedef istreambuf_iterator<_CharT, _Traits> _I;
            streamsize __n = __is.width();
-            if (__n <= 0)
+            if (__n == 0)
                __n = __str.max_size();
-            if (__n <= 0)
+            if (__n < 0)
                __n = numeric_limits<streamsize>::max();
            streamsize __c = 0;
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
-            ios_base::iostate __err = ios_base::goodbit;
-            while (__c < __n)
+            _I __i(__is);
+            _I __eof;
+            for (; __i != __eof && __c < __n; ++__i, ++__c)
            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __err |= ios_base::eofbit;
-                   break;
-                }
-                _CharT __ch = _Traits::to_char_type(__i);
+                _CharT __ch = *__i;
                if (__ct.is(__ct.space, __ch))
                    break;
                __str.push_back(__ch);
-                ++__c;
-                 __is.rdbuf()->sbumpc();
            }
            __is.width(0);
+            ios_base::iostate __err = ios_base::goodbit;
+            if (__i == __eof)
+               __err |= ios_base::eofbit;
            if (__c == 0)
               __err |= ios_base::failbit;
            __is.setstate(__err);
@@ -1585,28 +1618,31 @@ getline(basic_istream<_CharT, _Traits>& __is,
        if (__sen)
        {
            __str.clear();
-            ios_base::iostate __err = ios_base::goodbit;
-            streamsize __extr = 0;
-            while (true)
+            streamsize __c = 0;
+            typedef istreambuf_iterator<_CharT, _Traits> _I;
+            _I __i(__is);
+            _I __eof;
+            streamsize __n = __str.max_size();
+            if (__n < 0)
+                __n = numeric_limits<streamsize>::max();
+            for (; __i != __eof;)
            {
-                typename _Traits::int_type __i = __is.rdbuf()->sbumpc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __err |= ios_base::eofbit;
-                   break;
-                }
-                ++__extr;
-                _CharT __ch = _Traits::to_char_type(__i);
+                _CharT __ch = *__i;
+                ++__i;
+                ++__c;
                if (_Traits::eq(__ch, __dlm))
                    break;
-                __str.push_back(__ch);
-                if (__str.size() == __str.max_size())
+                if (__c == __n)
                {
-                    __err |= ios_base::failbit;
+                    __is.setstate(ios_base::failbit);
                    break;
                }
+                __str.push_back(__ch);
            }
-            if (__extr == 0)
+            ios_base::iostate __err = ios_base::goodbit;
+            if (__i == __eof)
+               __err |= ios_base::eofbit;
+            if (__c == 0)
               __err |= ios_base::failbit;
            __is.setstate(__err);
        }
@@ -1664,26 +1700,24 @@ operator>>(basic_istream<_CharT, _Traits>& __is, bitset<_Size>& __x)
        {
            basic_string<_CharT, _Traits> __str;
            const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__is.getloc());
+            typedef istreambuf_iterator<_CharT, _Traits> _I;
            streamsize __c = 0;
-            ios_base::iostate __err = ios_base::goodbit;
            _CharT __zero = __ct.widen('0');
            _CharT __one = __ct.widen('1');
-            while (__c < _Size)
+            _I __i(__is);
+            _I __eof;
+            for (; __i != __eof && __c < _Size; ++__i, ++__c)
            {
-                typename _Traits::int_type __i = __is.rdbuf()->sgetc();
-                if (_Traits::eq_int_type(__i, _Traits::eof()))
-                {
-                   __err |= ios_base::eofbit;
-                   break;
-                }
-                _CharT __ch = _Traits::to_char_type(__i);
-                if (!_Traits::eq(__ch, __zero) && !_Traits::eq(__ch, __one))
+                _CharT __ch = *__i;
+                if (__ch != __zero && __ch != __one)
                    break;
                __str.push_back(__ch);
-                ++__c;
-                 __is.rdbuf()->sbumpc();
            }
+            __is.width(0);
            __x = bitset<_Size>(__str);
+            ios_base::iostate __err = ios_base::goodbit;
+            if (__i == __eof)
+               __err |= ios_base::eofbit;
            if (__c == 0)
               __err |= ios_base::failbit;
            __is.setstate(__err);
--- a/include/iterator
+++ b/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)
 {
-    _VSTD::advance(__x, __n);
+    _STD::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)
 {
-    _VSTD::advance(__x, -__n);
+    _STD::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(_VSTD::move(__value)); return *this;}
+        {container->push_back(_STD::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(_VSTD::move(__value)); return *this;}
+        {container->push_front(_STD::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, _VSTD::move(__value)); ++iter; return *this;}
+        {iter = container->insert(iter, _STD::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;}
@@ -1007,35 +1007,35 @@ template <class _Iter> class __wrap_iter;

 template <class _Iter1, class _Iter2>
 bool
-operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter1, class _Iter2>
 bool
-operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter1, class _Iter2>
 bool
-operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter1, class _Iter2>
 bool
-operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter1, class _Iter2>
 bool
-operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter1, class _Iter2>
 bool
-operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter1, class _Iter2>
 typename __wrap_iter<_Iter1>::difference_type
-operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

 template <class _Iter>
 __wrap_iter<_Iter>
-operator+(typename __wrap_iter<_Iter>::difference_type, __wrap_iter<_Iter>) _NOEXCEPT;
+operator+(typename __wrap_iter<_Iter>::difference_type, const __wrap_iter<_Iter>&);

 template <class _I, class _O> _O copy(_I, _I, _O);
 template <class _B1, class _B2> _B2 copy_backward(_B1, _B1, _B2);
@@ -1063,108 +1063,33 @@ public:
 private:
    iterator_type __i;
 public:
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter() _NOEXCEPT
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        __get_db()->__insert_i(this);
-#endif
-    }
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter() {}
    template <class _Up> _LIBCPP_INLINE_VISIBILITY __wrap_iter(const __wrap_iter<_Up>& __u,
-        typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0) _NOEXCEPT
-        : __i(__u.base())
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        __get_db()->__iterator_copy(this, &__u);
-#endif
-    }
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    _LIBCPP_INLINE_VISIBILITY
-    __wrap_iter(const __wrap_iter& __x)
-        : __i(__x.base())
-    {
-        __get_db()->__iterator_copy(this, &__x);
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    __wrap_iter& operator=(const __wrap_iter& __x)
-    {
-        if (this != &__x)
-        {
-            __get_db()->__iterator_copy(this, &__x);
-            __i = __x.__i;
-        }
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY
-    ~__wrap_iter()
-    {
-        __get_db()->__erase_i(this);
-    }
-#endif
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const _NOEXCEPT
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
-                       "Attempted to dereference a non-dereferenceable iterator");
-#endif
-        return *__i;
-    }
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const _NOEXCEPT {return &(operator*());}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() _NOEXCEPT
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        _LIBCPP_ASSERT(__get_const_db()->__dereferenceable(this),
-                       "Attempted to increment non-incrementable iterator");
-#endif
-        ++__i;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator++(int) _NOEXCEPT
-        {__wrap_iter __tmp(*this); ++(*this); return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() _NOEXCEPT
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        _LIBCPP_ASSERT(__get_const_db()->__decrementable(this),
-                       "Attempted to decrement non-decrementable iterator");
-#endif
-        --__i;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator--(int) _NOEXCEPT
-        {__wrap_iter __tmp(*this); --(*this); return __tmp;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator+ (difference_type __n) const _NOEXCEPT
-        {__wrap_iter __w(*this); __w += __n; return __w;}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n) _NOEXCEPT
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        _LIBCPP_ASSERT(__get_const_db()->__addable(this, __n),
-                   "Attempted to add/subtract iterator outside of valid range");
-#endif
-        __i += __n;
-        return *this;
-    }
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator- (difference_type __n) const _NOEXCEPT
-        {return *this + (-__n);}
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n) _NOEXCEPT
-        {*this += -__n; return *this;}
-    _LIBCPP_INLINE_VISIBILITY reference        operator[](difference_type __n) const _NOEXCEPT
-    {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-        _LIBCPP_ASSERT(__get_const_db()->__subscriptable(this, __n),
-                   "Attempted to subscript iterator outside of valid range");
-#endif
-        return __i[__n];
-    }
+        typename enable_if<is_convertible<_Up, iterator_type>::value>::type* = 0)
+        : __i(__u.base()) {}
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__i;}
+    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return &(operator*());}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator++() {++__i; return *this;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator++(int)
+        {__wrap_iter __tmp(*this); ++__i; return __tmp;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator--() {--__i; return *this;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator--(int)
+        {__wrap_iter __tmp(*this); --__i; return __tmp;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator+ (difference_type __n) const
+        {return __wrap_iter(__i + __n);}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator+=(difference_type __n)
+        {__i += __n; return *this;}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter  operator- (difference_type __n) const
+        {return __wrap_iter(__i - __n);}
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter& operator-=(difference_type __n)
+        {__i -= __n; return *this;}
+    _LIBCPP_INLINE_VISIBILITY reference        operator[](difference_type __n) const
+        {return __i[__n];}

-    _LIBCPP_INLINE_VISIBILITY iterator_type base() const _NOEXCEPT {return __i;}
+    _LIBCPP_INLINE_VISIBILITY iterator_type base() const {return __i;}

 private:
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) _NOEXCEPT : __i(__x) {}
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    _LIBCPP_INLINE_VISIBILITY __wrap_iter(const void* __p, iterator_type __x) : __i(__x)
-    {
-        __get_db()->__insert_ic(this, __p);
-    }
-#endif
+    _LIBCPP_INLINE_VISIBILITY __wrap_iter(iterator_type __x) : __i(__x) {}

    template <class _Up> friend class __wrap_iter;
    template <class _CharT, class _Traits, class _Alloc> friend class basic_string;
@@ -1173,42 +1098,42 @@ private:
    template <class _Iter1, class _Iter2>
    friend
    bool
-    operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator==(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1, class _Iter2>
    friend
    bool
-    operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator<(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1, class _Iter2>
    friend
    bool
-    operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator!=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1, class _Iter2>
    friend
    bool
-    operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator>(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1, class _Iter2>
    friend
    bool
-    operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator>=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1, class _Iter2>
    friend
    bool
-    operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator<=(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1, class _Iter2>
    friend
    typename __wrap_iter<_Iter1>::difference_type
-    operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&) _NOEXCEPT;
+    operator-(const __wrap_iter<_Iter1>&, const __wrap_iter<_Iter2>&);

    template <class _Iter1>
    friend
    __wrap_iter<_Iter1>
-    operator+(typename __wrap_iter<_Iter1>::difference_type, __wrap_iter<_Iter1>) _NOEXCEPT;
+    operator+(typename __wrap_iter<_Iter1>::difference_type, const __wrap_iter<_Iter1>&);

    template <class _I, class _O> friend _O copy(_I, _I, _O);
    template <class _B1, class _B2> friend _B2 copy_backward(_B1, _B1, _B2);
@@ -1228,68 +1153,56 @@ private:
 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator==(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    _LIBCPP_ASSERT(__get_const_db()->__comparable(&__x, &__y),
-                   "Attempted to compare incomparable iterators");
-#endif
    return __x.base() == __y.base();
 }

 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator<(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    _LIBCPP_ASSERT(__get_const_db()->__comparable(&__x, &__y),
-                   "Attempted to compare incomparable iterators");
-#endif
    return __x.base() < __y.base();
 }

 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator!=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-    return !(__x == __y);
+    return __x.base() != __y.base();
 }

 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator>(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-    return __y < __x;
+    return __x.base() > __y.base();
 }

 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator>=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-    return !(__x < __y);
+    return __x.base() >= __y.base();
 }

 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator<=(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-    return !(__y < __x);
+    return __x.base() <= __y.base();
 }

 template <class _Iter1, class _Iter2>
 inline _LIBCPP_INLINE_VISIBILITY
 typename __wrap_iter<_Iter1>::difference_type
-operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y) _NOEXCEPT
+operator-(const __wrap_iter<_Iter1>& __x, const __wrap_iter<_Iter2>& __y)
 {
-#if _LIBCPP_DEBUG_LEVEL >= 2
-    _LIBCPP_ASSERT(__get_const_db()->__comparable(&__x, &__y),
-                   "Attempted to subtract incompatible iterators");
-#endif
    return __x.base() - __y.base();
 }

@@ -1297,10 +1210,9 @@ template <class _Iter>
 inline _LIBCPP_INLINE_VISIBILITY
 __wrap_iter<_Iter>
 operator+(typename __wrap_iter<_Iter>::difference_type __n,
-          __wrap_iter<_Iter> __x) _NOEXCEPT
+          const __wrap_iter<_Iter>& __x)
 {
-    __x += __n;
-    return __x;
+    return __wrap_iter<_Iter>(__x.base() + __n);
 }

 #ifdef _LIBCPP_DEBUG
--- a/include/limits
+++ b/include/limits
@@ -22,9 +22,9 @@ class numeric_limits
 {
 public:
    static const bool is_specialized = false;
-    static T min() noexcept;
-    static T max() noexcept;
-    static T lowest() noexcept;
+    static T min() throw();
+    static T max() throw();
+    static T lowest() throw();

    static const int  digits = 0;
    static const int  digits10 = 0;
@@ -33,8 +33,8 @@ public:
    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int  radix = 0;
-    static T epsilon() noexcept;
-    static T round_error() noexcept;
+    static T epsilon() throw();
+    static T round_error() throw();

    static const int  min_exponent = 0;
    static const int  min_exponent10 = 0;
@@ -46,10 +46,10 @@ public:
    static const bool has_signaling_NaN = false;
    static const float_denorm_style has_denorm = denorm_absent;
    static const bool has_denorm_loss = false;
-    static T infinity() noexcept;
-    static T quiet_NaN() noexcept;
-    static T signaling_NaN() noexcept;
-    static T denorm_min() noexcept;
+    static T infinity() throw();
+    static T quiet_NaN() throw();
+    static T signaling_NaN() throw();
+    static T denorm_min() throw();

    static const bool is_iec559 = false;
    static const bool is_bounded = false;
@@ -132,9 +132,9 @@ protected:
    typedef _Tp type;

    static const bool is_specialized = false;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return type();}

    static const int  digits = 0;
    static const int  digits10 = 0;
@@ -143,8 +143,8 @@ protected:
    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int  radix = 0;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return type();}

    static const int  min_exponent = 0;
    static const int  min_exponent10 = 0;
@@ -156,10 +156,10 @@ protected:
    static const bool has_signaling_NaN = false;
    static const float_denorm_style has_denorm = denorm_absent;
    static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return type();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return type();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return type();}

    static const bool is_iec559 = false;
    static const bool is_bounded = false;
@@ -196,15 +196,15 @@ protected:
    static const int  max_digits10 = 0;
    static const type __min = __libcpp_compute_min<type, digits, is_signed>::value;
    static const type __max = is_signed ? type(type(~0) ^ __min) : type(~0);
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __min;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __max;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return min();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __min;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __max;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return min();}

    static const bool is_integer = true;
    static const bool is_exact = true;
    static const int  radix = 2;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return type(0);}

    static const int  min_exponent = 0;
    static const int  min_exponent10 = 0;
@@ -216,10 +216,10 @@ protected:
    static const bool has_signaling_NaN = false;
    static const float_denorm_style has_denorm = denorm_absent;
    static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return type(0);}

    static const bool is_iec559 = false;
    static const bool is_bounded = true;
@@ -248,15 +248,15 @@ protected:
    static const int  max_digits10 = 0;
    static const type __min = false;
    static const type __max = true;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __min;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __max;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return min();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __min;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __max;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return min();}

    static const bool is_integer = true;
    static const bool is_exact = true;
    static const int  radix = 2;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return type(0);}

    static const int  min_exponent = 0;
    static const int  min_exponent10 = 0;
@@ -268,10 +268,10 @@ protected:
    static const bool has_signaling_NaN = false;
    static const float_denorm_style has_denorm = denorm_absent;
    static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return type(0);}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return type(0);}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return type(0);}

    static const bool is_iec559 = false;
    static const bool is_bounded = true;
@@ -294,15 +294,15 @@ protected:
    static const int  digits = __FLT_MANT_DIG__;
    static const int  digits10 = __FLT_DIG__;
    static const int  max_digits10 = 2+(digits * 30103)/100000;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __FLT_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __FLT_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return -max();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __FLT_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __FLT_MAX__;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return -max();}

    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __FLT_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return 0.5F;}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __FLT_EPSILON__;}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return 0.5F;}

    static const int  min_exponent = __FLT_MIN_EXP__;
    static const int  min_exponent10 = __FLT_MIN_10_EXP__;
@@ -314,10 +314,10 @@ protected:
    static const bool has_signaling_NaN = true;
    static const float_denorm_style has_denorm = denorm_present;
    static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __builtin_huge_valf();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __builtin_nanf("");}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __builtin_nansf("");}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __FLT_DENORM_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __builtin_huge_valf();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __builtin_nanf("");}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __builtin_nansf("");}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __FLT_DENORM_MIN__;}

    static const bool is_iec559 = true;
    static const bool is_bounded = true;
@@ -340,15 +340,15 @@ protected:
    static const int  digits = __DBL_MANT_DIG__;
    static const int  digits10 = __DBL_DIG__;
    static const int  max_digits10 = 2+(digits * 30103)/100000;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __DBL_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __DBL_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return -max();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __DBL_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __DBL_MAX__;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return -max();}

    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __DBL_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return 0.5;}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __DBL_EPSILON__;}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return 0.5;}

    static const int  min_exponent = __DBL_MIN_EXP__;
    static const int  min_exponent10 = __DBL_MIN_10_EXP__;
@@ -360,10 +360,10 @@ protected:
    static const bool has_signaling_NaN = true;
    static const float_denorm_style has_denorm = denorm_present;
    static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __builtin_huge_val();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __builtin_nan("");}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __builtin_nans("");}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __DBL_DENORM_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __builtin_huge_val();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __builtin_nan("");}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __builtin_nans("");}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __DBL_DENORM_MIN__;}

    static const bool is_iec559 = true;
    static const bool is_bounded = true;
@@ -386,15 +386,15 @@ protected:
    static const int  digits = __LDBL_MANT_DIG__;
    static const int  digits10 = __LDBL_DIG__;
    static const int  max_digits10 = 2+(digits * 30103)/100000;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __LDBL_MIN__;}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __LDBL_MAX__;}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return -max();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __LDBL_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __LDBL_MAX__;}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return -max();}

    static const bool is_integer = false;
    static const bool is_exact = false;
    static const int  radix = __FLT_RADIX__;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __LDBL_EPSILON__;}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return 0.5;}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __LDBL_EPSILON__;}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return 0.5;}

    static const int  min_exponent = __LDBL_MIN_EXP__;
    static const int  min_exponent10 = __LDBL_MIN_10_EXP__;
@@ -406,10 +406,10 @@ protected:
    static const bool has_signaling_NaN = true;
    static const float_denorm_style has_denorm = denorm_present;
    static const bool has_denorm_loss = false;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __builtin_huge_vall();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __builtin_nanl("");}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __builtin_nansl("");}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __LDBL_DENORM_MIN__;}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __builtin_huge_vall();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __builtin_nanl("");}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __builtin_nansl("");}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __LDBL_DENORM_MIN__;}

 #if (defined(__ppc__) || defined(__ppc64__))
    static const bool is_iec559 = false;
@@ -432,9 +432,9 @@ class _LIBCPP_VISIBLE numeric_limits
    typedef typename __base::type type;
 public:
    static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}

    static const int  digits = __base::digits;
    static const int  digits10 = __base::digits10;
@@ -443,8 +443,8 @@ public:
    static const bool is_integer = __base::is_integer;
    static const bool is_exact = __base::is_exact;
    static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}

    static const int  min_exponent = __base::min_exponent;
    static const int  min_exponent10 = __base::min_exponent10;
@@ -456,10 +456,10 @@ public:
    static const bool has_signaling_NaN = __base::has_signaling_NaN;
    static const float_denorm_style has_denorm = __base::has_denorm;
    static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}

    static const bool is_iec559 = __base::is_iec559;
    static const bool is_bounded = __base::is_bounded;
@@ -478,9 +478,9 @@ class _LIBCPP_VISIBLE numeric_limits<const _Tp>
    typedef _Tp type;
 public:
    static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}

    static const int  digits = __base::digits;
    static const int  digits10 = __base::digits10;
@@ -489,8 +489,8 @@ public:
    static const bool is_integer = __base::is_integer;
    static const bool is_exact = __base::is_exact;
    static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}

    static const int  min_exponent = __base::min_exponent;
    static const int  min_exponent10 = __base::min_exponent10;
@@ -502,10 +502,10 @@ public:
    static const bool has_signaling_NaN = __base::has_signaling_NaN;
    static const float_denorm_style has_denorm = __base::has_denorm;
    static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}

    static const bool is_iec559 = __base::is_iec559;
    static const bool is_bounded = __base::is_bounded;
@@ -524,9 +524,9 @@ class _LIBCPP_VISIBLE numeric_limits<volatile _Tp>
    typedef _Tp type;
 public:
    static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}

    static const int  digits = __base::digits;
    static const int  digits10 = __base::digits10;
@@ -535,8 +535,8 @@ public:
    static const bool is_integer = __base::is_integer;
    static const bool is_exact = __base::is_exact;
    static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}

    static const int  min_exponent = __base::min_exponent;
    static const int  min_exponent10 = __base::min_exponent10;
@@ -548,10 +548,10 @@ public:
    static const bool has_signaling_NaN = __base::has_signaling_NaN;
    static const float_denorm_style has_denorm = __base::has_denorm;
    static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}

    static const bool is_iec559 = __base::is_iec559;
    static const bool is_bounded = __base::is_bounded;
@@ -570,9 +570,9 @@ class _LIBCPP_VISIBLE numeric_limits<const volatile _Tp>
    typedef _Tp type;
 public:
    static const bool is_specialized = __base::is_specialized;
-    _LIBCPP_INLINE_VISIBILITY static type min() _NOEXCEPT {return __base::min();}
-    _LIBCPP_INLINE_VISIBILITY static type max() _NOEXCEPT {return __base::max();}
-    _LIBCPP_INLINE_VISIBILITY static type lowest() _NOEXCEPT {return __base::lowest();}
+    _LIBCPP_INLINE_VISIBILITY static type min() throw() {return __base::min();}
+    _LIBCPP_INLINE_VISIBILITY static type max() throw() {return __base::max();}
+    _LIBCPP_INLINE_VISIBILITY static type lowest() throw() {return __base::lowest();}

    static const int  digits = __base::digits;
    static const int  digits10 = __base::digits10;
@@ -581,8 +581,8 @@ public:
    static const bool is_integer = __base::is_integer;
    static const bool is_exact = __base::is_exact;
    static const int  radix = __base::radix;
-    _LIBCPP_INLINE_VISIBILITY static type epsilon() _NOEXCEPT {return __base::epsilon();}
-    _LIBCPP_INLINE_VISIBILITY static type round_error() _NOEXCEPT {return __base::round_error();}
+    _LIBCPP_INLINE_VISIBILITY static type epsilon() throw() {return __base::epsilon();}
+    _LIBCPP_INLINE_VISIBILITY static type round_error() throw() {return __base::round_error();}

    static const int  min_exponent = __base::min_exponent;
    static const int  min_exponent10 = __base::min_exponent10;
@@ -594,10 +594,10 @@ public:
    static const bool has_signaling_NaN = __base::has_signaling_NaN;
    static const float_denorm_style has_denorm = __base::has_denorm;
    static const bool has_denorm_loss = __base::has_denorm_loss;
-    _LIBCPP_INLINE_VISIBILITY static type infinity() _NOEXCEPT {return __base::infinity();}
-    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() _NOEXCEPT {return __base::quiet_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() _NOEXCEPT {return __base::signaling_NaN();}
-    _LIBCPP_INLINE_VISIBILITY static type denorm_min() _NOEXCEPT {return __base::denorm_min();}
+    _LIBCPP_INLINE_VISIBILITY static type infinity() throw() {return __base::infinity();}
+    _LIBCPP_INLINE_VISIBILITY static type quiet_NaN() throw() {return __base::quiet_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type signaling_NaN() throw() {return __base::signaling_NaN();}
+    _LIBCPP_INLINE_VISIBILITY static type denorm_min() throw() {return __base::denorm_min();}

    static const bool is_iec559 = __base::is_iec559;
    static const bool is_bounded = __base::is_bounded;
--- a/include/list
+++ b/include/list
--- a/include/locale
+++ b/include/locale
@@ -36,8 +36,8 @@ public:
        all = collate | ctype | monetary | numeric | time | messages;

    // construct/copy/destroy:
-    locale() noexcept;
-    locale(const locale& other) noexcept;
+    locale() throw();
+    locale(const locale& other) throw();
    explicit locale(const char* std_name);
    explicit locale(const string& std_name);
    locale(const locale& other, const char* std_name, category);
@@ -45,9 +45,9 @@ public:
    template <class Facet> locale(const locale& other, Facet* f);
    locale(const locale& other, const locale& one, category);

-    ~locale(); // not virtual
+    ~locale() throw(); // not virtual

-    const locale& operator=(const locale& other) noexcept;
+    const locale& operator=(const locale& other) throw();

    template <class Facet> locale combine(const locale& other) const;

@@ -65,7 +65,7 @@ public:
 };

 template <class Facet> const Facet& use_facet(const locale&);
-template <class Facet> bool has_facet(const locale&) noexcept;
+template <class Facet> bool has_facet(const locale&) throw();

 // 22.3.3, convenience interfaces:
 template <class charT> bool isspace (charT c, const locale& loc);
@@ -186,221 +186,155 @@ template <class charT> class messages_byname;
 #endif
 #include <cstdlib>
 #include <ctime>
-#if _WIN32
-#include <support/win32/locale_win32.h>
-#else // _WIN32
 #include <nl_types.h>
-#endif  // !_WIN32

 #pragma GCC system_header

 _LIBCPP_BEGIN_NAMESPACE_STD

-#if __APPLE__ || __FreeBSD__
-#  define _LIBCPP_GET_C_LOCALE 0
-#else
-#  define _LIBCPP_GET_C_LOCALE __cloc()
-   // Get the C locale object
-   locale_t __cloc();
-#define __cloc_defined
-#endif
-
-typedef _VSTD::remove_pointer<locale_t>::type __locale_struct;
-typedef _VSTD::unique_ptr<__locale_struct, decltype(&freelocale)> __locale_unique_ptr;
-typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
-
 // 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.
-#ifdef __linux__
+#if __APPLE__

-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-decltype(MB_CUR_MAX_L(_VSTD::declval<locale_t>()))
+template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-__mb_cur_max_l(locale_t __l)
+int
+__nolocale_sprintf(char* __restrict __str,
+                   const char* __restrict __format, _Tp __v)
 {
-  return MB_CUR_MAX_L(__l);
+    return sprintf_l(__str, 0, __format, __v);
 }
-#else  // _LIBCPP_LOCALE__L_EXTENSIONS
-_LIBCPP_ALWAYS_INLINE inline
-decltype(MB_CUR_MAX) __mb_cur_max_l(locale_t __l)
+
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_snprintf(char* __restrict __str, size_t __size,
+                    const char* __restrict __format, _Tp __v)
 {
-  __locale_raii __current(uselocale(__l), uselocale);
-  return MB_CUR_MAX;
+    return snprintf_l(__str, __size, 0, __format, __v);
 }
-#endif // _LIBCPP_LOCALE__L_EXTENSIONS

-_LIBCPP_ALWAYS_INLINE inline
-wint_t __btowc_l(int __c, locale_t __l)
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_snprintf(char* __restrict __str, size_t __size,
+                    const char* __restrict __format, int __prec, _Tp __v)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return btowc_l(__c, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return btowc(__c);
-#endif
+    return snprintf_l(__str, __size, 0, __format, __prec, __v);
 }

-_LIBCPP_ALWAYS_INLINE inline
-int __wctob_l(wint_t __c, locale_t __l)
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_asprintf(char** __ret, const char* __restrict __format, _Tp __v)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return wctob_l(__c, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return wctob(__c);
-#endif
+    return asprintf_l(__ret, 0, __format, __v);
 }

-_LIBCPP_ALWAYS_INLINE inline
-size_t __wcsnrtombs_l(char *__dest, const wchar_t **__src, size_t __nwc,
-                      size_t __len, mbstate_t *__ps, locale_t __l)
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_asprintf(char** __ret, const char* __restrict __format, int __prec,
+                                                                        _Tp __v)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return wcsnrtombs_l(__dest, __src, __nwc, __len, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return wcsnrtombs(__dest, __src, __nwc, __len, __ps);
-#endif
+    return asprintf_l(__ret, 0, __format, __prec, __v);
 }

-_LIBCPP_ALWAYS_INLINE inline
-size_t __wcrtomb_l(char *__s, wchar_t __wc, mbstate_t *__ps, locale_t __l)
+template <class _Tp>
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_sscanf(const char* __restrict __str,
+                  const char* __restrict __format, _Tp* __v)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return wcrtomb_l(__s, __wc, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return wcrtomb(__s, __wc, __ps);
-#endif
+    return sscanf_l(__str, 0, __format, __v);
 }

-_LIBCPP_ALWAYS_INLINE inline
-size_t __mbsnrtowcs_l(wchar_t * __dest, const char **__src, size_t __nms,
-                      size_t __len, mbstate_t *__ps, locale_t __l)
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_isxdigit(int __c)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbsnrtowcs_l(__dest, __src, __nms, __len, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbsnrtowcs(__dest, __src, __nms, __len, __ps);
-#endif
+    return isxdigit_l(__c, 0);
 }

-_LIBCPP_ALWAYS_INLINE inline
-size_t __mbrtowc_l(wchar_t *__pwc, const char *__s, size_t __n,
-                   mbstate_t *__ps, locale_t __l)
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_isdigit(int __c)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbrtowc_l(__pwc, __s, __n, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbrtowc(__pwc, __s, __n, __ps);
-#endif
+    return isdigit_l(__c, 0);
 }

-_LIBCPP_ALWAYS_INLINE inline
-int __mbtowc_l(wchar_t *__pwc, const char *__pmb, size_t __max, locale_t __l)
+#else  // __APPLE__
+inline
+#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
+_LIBCPP_INLINE_VISIBILITY
+#endif
+int
+__nolocale_sprintf(char* __restrict __str,
+                   const char* __restrict __format, ...)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbtowc_l(__pwc, __pmb, __max, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbtowc(__pwc, __pmb, __max);
-#endif
+    va_list __ap;
+    va_start(__ap, __format);
+    int __result = vsprintf(__str, __format, __ap);
+    va_end(__ap);
+    return __result;
 }
-
-_LIBCPP_ALWAYS_INLINE inline
-size_t __mbrlen_l(const char *__s, size_t __n, mbstate_t *__ps, locale_t __l)
+inline
+#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
+_LIBCPP_INLINE_VISIBILITY
+#endif
+int
+__nolocale_snprintf(char* __restrict __str, size_t __size,
+                    const char* __restrict __format, ...)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbrlen_l(__s, __n, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbrlen(__s, __n, __ps);
-#endif
+    va_list __ap;
+    va_start(__ap, __format);
+    int __result = vsnprintf(__str, __size, __format, __ap);
+    va_end(__ap);
+    return __result;
 }
-
-_LIBCPP_ALWAYS_INLINE inline
-lconv *__localeconv_l(locale_t __l)
+inline
+#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
+_LIBCPP_INLINE_VISIBILITY
+#endif
+int
+__nolocale_asprintf(char** __ret,
+                    const char* __restrict __format, ...)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return localeconv_l(__l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return localeconv();
-#endif
+    va_list __ap;
+    va_start(__ap, __format);
+    int __result = vasprintf(__ret, __format, __ap);
+    va_end(__ap);
+    return __result;
 }
-
-_LIBCPP_ALWAYS_INLINE inline
-size_t __mbsrtowcs_l(wchar_t *__dest, const char **__src, size_t __len,
-                     mbstate_t *__ps, locale_t __l)
+inline
+#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
+_LIBCPP_INLINE_VISIBILITY
+#endif
+int
+__nolocale_sscanf(const char* __restrict __str,
+                  const char* __restrict __format, ...)
 {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  return mbsrtowcs_l(__dest, __src, __len, __ps, __l);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  return mbsrtowcs(__dest, __src, __len, __ps);
-#endif
+    va_list __ap;
+    va_start(__ap, __format);
+    int __result = vsscanf(__str, __format, __ap);
+    va_end(__ap);
+    return __result;
+}
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_isxdigit(int __c)
+{
+    return isxdigit(__c);
 }

-_LIBCPP_ALWAYS_INLINE inline
-int __sprintf_l(char *__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vsprintf_l(__s, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vsprintf(__s, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
+inline _LIBCPP_INLINE_VISIBILITY
+int
+__nolocale_isdigit(int __c)
+{
+    return isdigit(__c);
 }
-
-_LIBCPP_ALWAYS_INLINE inline
-int __snprintf_l(char *__s, size_t __n, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vsnprintf_l(__s, __n, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vsnprintf(__s, __n, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
-}
-
-_LIBCPP_ALWAYS_INLINE inline
-int __asprintf_l(char **__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vasprintf_l(__s, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vasprintf(__s, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
-}
-
-_LIBCPP_ALWAYS_INLINE inline
-int __sscanf_l(const char *__s, locale_t __l, const char *__format, ...) {
-  va_list __va;
-  va_start(__va, __format);
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-  int __res = vsscanf_l(__s, __l, __format, __va);
-#else
-  __locale_raii __current(uselocale(__l), uselocale);
-  int __res = vsscanf(__s, __format, __va);
-#endif
-  va_end(__va);
-  return __res;
-}
-
-#endif  // __linux__
+#endif  // __APPLE__

 // __scan_keyword
 // Scans [__b, __e) until a match is found in the basic_strings range
@@ -429,7 +363,7 @@ __scan_keyword(_InputIterator& __b, _InputIterator __e,
               bool __case_sensitive = true)
 {
    typedef typename iterator_traits<_InputIterator>::value_type _CharT;
-    size_t __nkw = _VSTD::distance(__kb, __ke);
+    size_t __nkw = _STD::distance(__kb, __ke);
    const unsigned char __doesnt_match = '\0';
    const unsigned char __might_match = '\1';
    const unsigned char __does_match = '\2';
@@ -814,7 +748,7 @@ __num_get_signed_integral(const char* __a, const char* __a_end,
        int __save_errno = errno;
        errno = 0;
        char *__p2;
-        long long __ll = strtoll_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
+        long long __ll = strtoll_l(__a, &__p2, __base, 0);
        int __current_errno = errno;
        if (__current_errno == 0)
            errno = __save_errno;
@@ -854,7 +788,7 @@ __num_get_unsigned_integral(const char* __a, const char* __a_end,
        int __save_errno = errno;
        errno = 0;
        char *__p2;
-        unsigned long long __ll = strtoull_l(__a, &__p2, __base, _LIBCPP_GET_C_LOCALE);
+        unsigned long long __ll = strtoull_l(__a, &__p2, __base, 0);
        int __current_errno = errno;
        if (__current_errno == 0)
            errno = __save_errno;
@@ -882,7 +816,7 @@ __num_get_float(const char* __a, const char* __a_end, ios_base::iostate& __err)
    if (__a != __a_end)
    {
        char *__p2;
-        long double __ld = strtold_l(__a, &__p2, _LIBCPP_GET_C_LOCALE);
+        long double __ld = strtold_l(__a, &__p2, 0);
        if (__p2 != __a_end)
        {
            __err = ios_base::failbit;
@@ -1287,11 +1221,7 @@ num_get<_CharT, _InputIterator>::do_get(iter_type __b, iter_type __e,
            break;
    // Stage 3
    __a[sizeof(__a)-1] = 0;
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    if (sscanf_l(__a, _LIBCPP_GET_C_LOCALE, "%p", &__v) != 1)
-#else
-    if (__sscanf_l(__a, __cloc(), "%p", &__v) != 1)
-#endif
+    if (__nolocale_sscanf(__a, "%p", &__v) != 1)
        __err = ios_base::failbit;
    // EOF checked
    if (__b == __e)
@@ -1396,13 +1326,13 @@ __num_put<_CharT>::__widen_and_group_float(char* __nb, char* __np, char* __ne,
        *__oe++ = __ct.widen(*__nf++);
        *__oe++ = __ct.widen(*__nf++);
        for (__ns = __nf; __ns < __ne; ++__ns)
-            if (!isxdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
+            if (!__nolocale_isxdigit(*__ns))
                break;
    }
    else
    {
        for (__ns = __nf; __ns < __ne; ++__ns)
-            if (!isdigit_l(*__ns, _LIBCPP_GET_C_LOCALE))
+            if (!__nolocale_isdigit(*__ns))
                break;
    }
    if (__grouping.empty())
@@ -1600,11 +1530,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                          + ((numeric_limits<long>::digits % 3) != 0)
                          + 1;
    char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
-#endif
+    int __nc = __nolocale_sprintf(__nar, __fmt, __v);
    char* __ne = __nar + __nc;
    char* __np = this->__identify_padding(__nar, __ne, __iob);
    // Stage 2 - Widen __nar while adding thousands separators
@@ -1630,11 +1556,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                          + ((numeric_limits<long long>::digits % 3) != 0)
                          + 1;
    char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
-#endif
+    int __nc = __nolocale_sprintf(__nar, __fmt, __v);
    char* __ne = __nar + __nc;
    char* __np = this->__identify_padding(__nar, __ne, __iob);
    // Stage 2 - Widen __nar while adding thousands separators
@@ -1660,11 +1582,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                          + ((numeric_limits<unsigned long>::digits % 3) != 0)
                          + 1;
    char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
-#endif
+    int __nc = __nolocale_sprintf(__nar, __fmt, __v);
    char* __ne = __nar + __nc;
    char* __np = this->__identify_padding(__nar, __ne, __iob);
    // Stage 2 - Widen __nar while adding thousands separators
@@ -1690,11 +1608,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
                          + ((numeric_limits<unsigned long long>::digits % 3) != 0)
                          + 1;
    char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
-#endif
+    int __nc = __nolocale_sprintf(__nar, __fmt, __v);
    char* __ne = __nar + __nc;
    char* __np = this->__identify_padding(__nar, __ne, __iob);
    // Stage 2 - Widen __nar while adding thousands separators
@@ -1721,35 +1635,18 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
    char* __nb = __nar;
    int __nc;
    if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
+        __nc = __nolocale_snprintf(__nb, __nbuf, __fmt,
                                   (int)__iob.precision(), __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt,
-                            (int)__iob.precision(), __v);
-#endif
    else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v);
-#endif
+        __nc = __nolocale_snprintf(__nb, __nbuf, __fmt, __v);
    unique_ptr<char, void(*)(void*)> __nbh(0, free);
    if (__nc > static_cast<int>(__nbuf-1))
    {
        if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#else
-            __nc = __asprintf_l(&__nb, __cloc(), __fmt,
-                              (int)__iob.precision(), __v);
-#endif
+            __nc = __nolocale_asprintf(&__nb, __fmt, (int)__iob.precision(),
+                                       __v);
        else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-            __nc = __asprintf_l(&__nb, __cloc(), __fmt, (int)__iob.precision(), __v);
-#endif
+            __nc = __nolocale_asprintf(&__nb, __fmt, __v);
        if (__nb == 0)
            __throw_bad_alloc();
        __nbh.reset(__nb);
@@ -1790,35 +1687,18 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
    char* __nb = __nar;
    int __nc;
    if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt,
+        __nc = __nolocale_snprintf(__nb, __nbuf, __fmt,
                                   (int)__iob.precision(), __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt,
-                            (int)__iob.precision(), __v);
-#endif
    else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __nc = snprintf_l(__nb, __nbuf, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-        __nc = __snprintf_l(__nb, __nbuf, __cloc(), __fmt, __v);
-#endif
+        __nc = __nolocale_snprintf(__nb, __nbuf, __fmt, __v);
    unique_ptr<char, void(*)(void*)> __nbh(0, free);
    if (__nc > static_cast<int>(__nbuf-1))
    {
        if (__specify_precision)
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, (int)__iob.precision(), __v);
-#else
-            __nc = __asprintf_l(&__nb, __cloc(), __fmt,
-                              (int)__iob.precision(), __v);
-#endif
+            __nc = __nolocale_asprintf(&__nb, __fmt, (int)__iob.precision(),
+                                       __v);
        else
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-            __nc = asprintf_l(&__nb, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-            __nc = __asprintf_l(&__nb, __cloc(), __fmt, __v);
-#endif
+            __nc = __nolocale_asprintf(&__nb, __fmt, __v);
        if (__nb == 0)
            __throw_bad_alloc();
        __nbh.reset(__nb);
@@ -1854,11 +1734,7 @@ num_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
    char __fmt[6] = "%p";
    const unsigned __nbuf = 20;
    char __nar[__nbuf];
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-    int __nc = sprintf_l(__nar, _LIBCPP_GET_C_LOCALE, __fmt, __v);
-#else
-    int __nc = __sprintf_l(__nar, __cloc(), __fmt, __v);
-#endif
+    int __nc = __nolocale_sprintf(__nar, __fmt, __v);
    char* __ne = __nar + __nc;
    char* __np = this->__identify_padding(__nar, __ne, __iob);
    // Stage 2 - Widen __nar
@@ -2635,7 +2511,7 @@ class __time_put
 {
    locale_t __loc_;
 protected:
-    _LIBCPP_ALWAYS_INLINE __time_put() : __loc_(_LIBCPP_GET_C_LOCALE) {}
+    _LIBCPP_ALWAYS_INLINE __time_put() : __loc_(0) {}
    __time_put(const char* __nm);
    __time_put(const string& __nm);
    ~__time_put();
@@ -2738,7 +2614,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 _VSTD::copy(__nb, __ne, __s);
+    return _STD::copy(__nb, __ne, __s);
 }

 extern template class time_put<char>;
@@ -3406,7 +3282,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 = _VSTD::copy(__sym.begin(), __sym.end(), __me);
+                __me = _STD::copy(__sym.begin(), __sym.end(), __me);
            break;
        case money_base::value:
            {
@@ -3465,7 +3341,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 = _VSTD::copy(__sn.begin()+1, __sn.end(), __me);
+        __me = _STD::copy(__sn.begin()+1, __sn.end(), __me);
    // set alignment
    if ((__flags & ios_base::adjustfield) == ios_base::left)
        __mi = __me;
@@ -3538,11 +3414,7 @@ money_put<_CharT, _OutputIterator>::do_put(iter_type __s, bool __intl,
    // secure memory for digit storage
    if (__n > __bs-1)
    {
-#ifdef _LIBCPP_LOCALE__L_EXTENSIONS
-        __n = asprintf_l(&__bb, _LIBCPP_GET_C_LOCALE, "%.0Lf", __units);
-#else
-        __n = __asprintf_l(&__bb, __cloc(), "%.0Lf", __units);
-#endif
+        __n = __nolocale_asprintf(&__bb, "%.0Lf", __units);
        if (__bb == 0)
            __throw_bad_alloc();
        __hn.reset(__bb);
@@ -3693,14 +3565,10 @@ template <class _CharT>
 typename messages<_CharT>::catalog
 messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
 {
-#if _WIN32
-    return -1;
-#else // _WIN32
-    catalog __cat = (catalog)catopen(__nm.c_str(), NL_CAT_LOCALE);
+    catalog __cat = reinterpret_cast<catalog>(catopen(__nm.c_str(), NL_CAT_LOCALE));
    if (__cat != -1)
        __cat = static_cast<catalog>((static_cast<size_t>(__cat) >> 1));
    return __cat;
-#endif // _WIN32
 }

 template <class _CharT>
@@ -3708,34 +3576,28 @@ typename messages<_CharT>::string_type
 messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
                         const string_type& __dflt) const
 {
-#if _WIN32
-    return __dflt;
-#else // _WIN32
    string __ndflt;
    __narrow_to_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__ndflt),
                                                       __dflt.c_str(),
                                                       __dflt.c_str() + __dflt.size());
    if (__c != -1)
        __c <<= 1;
-    nl_catd __cat = (nl_catd)__c;
+    nl_catd __cat = reinterpret_cast<nl_catd>(__c);
    char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
    string_type __w;
    __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w),
                                                        __n, __n + strlen(__n));
    return __w;
-#endif // _WIN32
 }

 template <class _CharT>
 void
 messages<_CharT>::do_close(catalog __c) const
 {
-#if !_WIN32
    if (__c != -1)
        __c <<= 1;
-    nl_catd __cat = (nl_catd)__c;
+    nl_catd __cat = reinterpret_cast<nl_catd>(__c);
    catclose(__cat);
-#endif // !_WIN32
 }

 extern template class messages<char>;
@@ -3854,8 +3716,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_(_VSTD::move(__wc.__byte_err_string_)),
-          __wide_err_string_(_VSTD::move(__wc.__wide_err_string_)),
+        : __byte_err_string_(_STD::move(__wc.__byte_err_string_)),
+          __wide_err_string_(_STD::move(__wc.__wide_err_string_)),
          __cvtptr_(__wc.__cvtptr_),
          __cvtstate_(__wc.__cvtstate_), __cvtcount_(__wc.__cvtstate_)
 {
@@ -4148,7 +4010,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 = _VSTD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
+            streamsize __nmemb = _STD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
                                 static_cast<streamsize>(__extbufend_ - __extbufnext_));
            codecvt_base::result __r;
            state_type __svs = __st_;
--- a/include/map
+++ b/include/map
--- a/include/memory
+++ b/include/memory
--- a/include/mutex
+++ b/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_(_VSTD::move(__f)) {}
+    explicit __call_once_param(_F&& __f) : __f_(_STD::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(_VSTD::move(_VSTD::get<0>(__f_)), _VSTD::move(_VSTD::get<_Indices>(__f_))...);
+        __invoke(_STD::move(_STD::get<0>(__f_)), _STD::move(_STD::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_(_VSTD::move(__f)) {}
+    explicit __call_once_param(_F&& __f) : __f_(_STD::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(_VSTD::forward<_Callable>(__func)),
-                                __decay_copy(_VSTD::forward<_Args>(__args))...));
+        __call_once_param<_G> __p(_G(__decay_copy(_STD::forward<_Callable>(__func)),
+                                __decay_copy(_STD::forward<_Args>(__args))...));
        __call_once(__flag.__state_, &__p, &__call_once_proxy<_G>);
    }
 }
--- a/include/new
+++ b/include/new
@@ -21,34 +21,35 @@ class bad_alloc
    : public exception
 {
 public:
-    bad_alloc() noexcept;
-    bad_alloc(const bad_alloc&) noexcept;
-    bad_alloc& operator=(const bad_alloc&) noexcept;
-    virtual const char* what() const noexcept;
+    bad_alloc() throw();
+    bad_alloc(const bad_alloc&) throw();
+    bad_alloc& operator=(const bad_alloc&) throw();
+    virtual ~bad_alloc() throw();
+    virtual const char* what() const throw();
 };

 struct nothrow_t {};
 extern const nothrow_t nothrow;
 typedef void (*new_handler)();
-new_handler set_new_handler(new_handler new_p) noexcept;
-new_handler get_new_handler() noexcept;
+new_handler set_new_handler(new_handler new_p) throw();
+new_handler get_new_handler() throw();

 }  // std

-void* operator new(std::size_t size);                                   // replaceable
-void* operator new(std::size_t size, const std::nothrow_t&) noexcept;   // replaceable
-void  operator delete(void* ptr) noexcept;                              // replaceable
-void  operator delete(void* ptr, const std::nothrow_t&) noexcept;       // replaceable
+void* operator new(std::size_t size) throw(std::bad_alloc);            // replaceable
+void* operator new(std::size_t size, const std::nothrow_t&) throw();   // replaceable
+void  operator delete(void* ptr) throw();                              // replaceable
+void  operator delete(void* ptr, const std::nothrow_t&) throw();       // replaceable

-void* operator new[](std::size_t size);                                 // replaceable
-void* operator new[](std::size_t size, const std::nothrow_t&) noexcept; // replaceable
-void  operator delete[](void* ptr) noexcept;                            // replaceable
-void  operator delete[](void* ptr, const std::nothrow_t&) noexcept;     // replaceable
+void* operator new[](std::size_t size) throw(std::bad_alloc);          // replaceable
+void* operator new[](std::size_t size, const std::nothrow_t&) throw(); // replaceable
+void  operator delete[](void* ptr) throw();                            // replaceable
+void  operator delete[](void* ptr, const std::nothrow_t&) throw();     // replaceable

-void* operator new  (std::size_t size, void* ptr) noexcept;
-void* operator new[](std::size_t size, void* ptr) noexcept;
-void  operator delete  (void* ptr, void*) noexcept;
-void  operator delete[](void* ptr, void*) noexcept;
+void* operator new  (std::size_t size, void* ptr) throw();
+void* operator new[](std::size_t size, void* ptr) throw();
+void  operator delete  (void* ptr, void*) throw();
+void  operator delete[](void* ptr, void*) throw();

 */

@@ -65,18 +66,18 @@ class _LIBCPP_EXCEPTION_ABI bad_alloc
    : public exception
 {
 public:
-    bad_alloc() _NOEXCEPT;
-    virtual ~bad_alloc() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_alloc() throw();
+    virtual ~bad_alloc() throw();
+    virtual const char* what() const throw();
 };

 class _LIBCPP_EXCEPTION_ABI bad_array_new_length
    : public bad_alloc
 {
 public:
-    bad_array_new_length() _NOEXCEPT;
-    virtual ~bad_array_new_length() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_array_new_length() throw();
+    virtual ~bad_array_new_length() throw();
+    virtual const char* what() const throw();
 };

 void __throw_bad_alloc();  // not in C++ spec
@@ -84,32 +85,24 @@ void __throw_bad_alloc();  // not in C++ spec
 struct _LIBCPP_VISIBLE nothrow_t {};
 extern _LIBCPP_VISIBLE const nothrow_t nothrow;
 typedef void (*new_handler)();
-_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) _NOEXCEPT;
-_LIBCPP_VISIBLE new_handler get_new_handler() _NOEXCEPT;
+_LIBCPP_VISIBLE new_handler set_new_handler(new_handler) throw();
+_LIBCPP_VISIBLE new_handler get_new_handler() throw();

 }  // std

-_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 __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) throw(std::bad_alloc);
+_LIBCPP_VISIBLE void* operator new(std::size_t, const std::nothrow_t&) throw();
+_LIBCPP_VISIBLE void  operator delete(void*) throw();
+_LIBCPP_VISIBLE void  operator delete(void*, const std::nothrow_t&) throw();

-_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 __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) throw(std::bad_alloc);
+_LIBCPP_VISIBLE void* operator new[](std::size_t, const std::nothrow_t&) throw();
+_LIBCPP_VISIBLE void  operator delete[](void*) throw();
+_LIBCPP_VISIBLE void  operator delete[](void*, const std::nothrow_t&) throw();

-_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;}
-_LIBCPP_INLINE_VISIBILITY inline void  operator delete  (void*, void*) _NOEXCEPT {}
-_LIBCPP_INLINE_VISIBILITY inline void  operator delete[](void*, void*) _NOEXCEPT {}
+_LIBCPP_INLINE_VISIBILITY inline void* operator new  (std::size_t, void* __p) throw() {return __p;}
+_LIBCPP_INLINE_VISIBILITY inline void* operator new[](std::size_t, void* __p) throw() {return __p;}
+_LIBCPP_INLINE_VISIBILITY inline void  operator delete  (void*, void*) throw() {}
+_LIBCPP_INLINE_VISIBILITY inline void  operator delete[](void*, void*) throw() {}

 #endif  // _LIBCPP_NEW
--- a/include/ostream
+++ b/include/ostream
@@ -154,13 +154,11 @@ 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);
--- a/include/queue
+++ b/include/queue
@@ -31,28 +31,21 @@ protected:
    container_type c;

 public:
-    queue() = default;
-    ~queue() = default;
-
-    queue(const queue& q) = default;
-    queue(queue&& q) = default;
-
-    queue& operator=(const queue& q) = default;
-    queue& operator=(queue&& q) = default;
-
+    queue();
    explicit queue(const container_type& c);
-    explicit queue(container_type&& c)
+    explicit queue(container_type&& c);
+    queue(queue&& q);
    template <class Alloc>
        explicit queue(const Alloc& a);
    template <class Alloc>
        queue(const container_type& c, const Alloc& a);
    template <class Alloc>
        queue(container_type&& c, const Alloc& a);
-    template <class Alloc>
-        queue(const queue& q, const Alloc& a);
    template <class Alloc>
        queue(queue&& q, const Alloc& a);

+    queue& operator=(queue&& q);
+
    bool      empty() const;
    size_type size() const;

@@ -66,7 +59,7 @@ public:
    template <class... Args> void emplace(Args&&... args);
    void pop();

-    void swap(queue& q) noexcept(noexcept(swap(c, q.c)));
+    void swap(queue& q);
 };

 template <class T, class Container>
@@ -88,8 +81,7 @@ template <class T, class Container>
  bool operator<=(const queue<T, Container>& x,const queue<T, Container>& y);

 template <class T, class Container>
-  void swap(queue<T, Container>& x, queue<T, Container>& y)
-  noexcept(noexcept(x.swap(y)));
+  void swap(queue<T, Container>& x, queue<T, Container>& y);

 template <class T, class Container = vector<T>,
          class Compare = less<typename Container::value_type>>
@@ -107,16 +99,7 @@ protected:
    Compare comp;

 public:
-    priority_queue() = default;
-    ~priority_queue() = default;
-
-    priority_queue(const priority_queue& q) = default;
-    priority_queue(priority_queue&& q) = default;
-
-    priority_queue& operator=(const priority_queue& q) = default;
-    priority_queue& operator=(priority_queue&& q) = default;
-
-    explicit priority_queue(const Compare& comp);
+    explicit priority_queue(const Compare& comp = Compare());
    priority_queue(const Compare& comp, const container_type& c);
    explicit priority_queue(const Compare& comp, container_type&& c);
    template <class InputIterator>
@@ -128,6 +111,8 @@ public:
    template <class InputIterator>
        priority_queue(InputIterator first, InputIterator last,
                       const Compare& comp, container_type&& c);
+    priority_queue(priority_queue&& q);
+    priority_queue& operator=(priority_queue&& q);
    template <class Alloc>
        explicit priority_queue(const Alloc& a);
    template <class Alloc>
@@ -138,8 +123,6 @@ public:
    template <class Alloc>
        priority_queue(const Compare& comp, container_type&& c,
                       const Alloc& a);
-    template <class Alloc>
-        priority_queue(const priority_queue& q, const Alloc& a);
    template <class Alloc>
        priority_queue(priority_queue&& q, const Alloc& a);

@@ -152,14 +135,12 @@ public:
    template <class... Args> void emplace(Args&&... args);
    void pop();

-    void swap(priority_queue& q)
-        noexcept(noexcept(swap(c, q.c)) && noexcept(swap(comp.q.comp)));
+    void swap(priority_queue& q);
 };

 template <class T, class Container, class Compare>
  void swap(priority_queue<T, Container, Compare>& x,
-            priority_queue<T, Container, Compare>& y)
-            noexcept(noexcept(x.swap(y)));
+            priority_queue<T, Container, Compare>& y);

 }  // std

@@ -200,35 +181,14 @@ protected:

 public:
    _LIBCPP_INLINE_VISIBILITY
-    queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    queue(const queue& __q) : c(__q.c) {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    queue(queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_VSTD::move(__q.c)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    queue& operator=(const queue& __q) {c = __q.c; return *this;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    queue& operator=(queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _VSTD::move(__q.c); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
+    queue() : c() {}
    _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(_VSTD::move(__c)) {}
+    explicit queue(container_type&& __c) : c(_STD::move(__c)) {}
+    _LIBCPP_INLINE_VISIBILITY
+    queue(queue&& __q) : c(_STD::move(__q.c)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _Alloc>
        _LIBCPP_INLINE_VISIBILITY
@@ -254,14 +214,20 @@ public:
        queue(container_type&& __c, const _Alloc& __a,
                       typename enable_if<uses_allocator<container_type,
                                                         _Alloc>::value>::type* = 0)
-            : c(_VSTD::move(__c), __a) {}
+            : c(_STD::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(_VSTD::move(__q.c), __a) {}
+            : c(_STD::move(__q.c), __a) {}

+    _LIBCPP_INLINE_VISIBILITY
+    queue& operator=(queue&& __q)
+    {
+        c = _STD::move(__q.c);
+        return *this;
+    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
@@ -282,12 +248,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(_VSTD::move(__v));}
+    void push(value_type&& __v)      {c.push_back(_STD::move(__v));}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        void emplace(_Args&&... __args)
-            {c.emplace_back(_VSTD::forward<_Args>(__args)...);}
+            {c.emplace_back(_STD::forward<_Args>(__args)...);}
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
@@ -295,9 +261,8 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    void swap(queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
    {
-        using _VSTD::swap;
+        using _STD::swap;
        swap(c, __q.c);
    }

@@ -366,7 +331,6 @@ template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(queue<_Tp, _Container>& __x, queue<_Tp, _Container>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
@@ -395,36 +359,7 @@ protected:

 public:
    _LIBCPP_INLINE_VISIBILITY
-    priority_queue()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value &&
-                   is_nothrow_default_constructible<value_compare>::value)
-        : c(), comp() {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(const priority_queue& __q) : c(__q.c), comp(__q.comp) {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue(priority_queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value &&
-                   is_nothrow_move_constructible<value_compare>::value)
-        : c(_VSTD::move(__q.c)), comp(_VSTD::move(__q.comp)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue& operator=(const priority_queue& __q)
-        {c = __q.c; comp = __q.comp; return *this;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    priority_queue& operator=(priority_queue&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value &&
-                   is_nothrow_move_assignable<value_compare>::value)
-        {c = _VSTD::move(__q.c); comp = _VSTD::move(__q.comp); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    explicit priority_queue(const value_compare& __comp)
+    explicit priority_queue(const value_compare& __comp = value_compare())
        : c(), comp(__comp) {}
    priority_queue(const value_compare& __comp, const container_type& __c);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -440,6 +375,8 @@ public:
    template <class _InputIter>
        priority_queue(_InputIter __f, _InputIter __l,
                       const value_compare& __comp, container_type&& __c);
+    priority_queue(priority_queue&& __q);
+    priority_queue& operator=(priority_queue&& __q);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _Alloc>
        explicit priority_queue(const _Alloc& __a,
@@ -486,9 +423,7 @@ public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void pop();

-    void swap(priority_queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
-                   __is_nothrow_swappable<value_compare>::value);
+    void swap(priority_queue& __q);
 };

 template <class _Tp, class _Container, class _Compare>
@@ -498,7 +433,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const _Compare& __comp
    : c(__c),
      comp(__comp)
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -507,10 +442,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(_VSTD::move(__c)),
+    : c(_STD::move(__c)),
      comp(__comp)
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -523,7 +458,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
    : c(__f, __l),
      comp(__comp)
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 template <class _Tp, class _Container, class _Compare>
@@ -536,7 +471,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _Input
      comp(__comp)
 {
    c.insert(c.end(), __f, __l);
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -547,11 +482,28 @@ inline _LIBCPP_INLINE_VISIBILITY
 priority_queue<_Tp, _Container, _Compare>::priority_queue(_InputIter __f, _InputIter __l,
                                                          const value_compare& __comp,
                                                          container_type&& __c)
-    : c(_VSTD::move(__c)),
+    : c(_STD::move(__c)),
      comp(__comp)
 {
    c.insert(c.end(), __f, __l);
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
+}
+
+template <class _Tp, class _Container, class _Compare>
+inline _LIBCPP_INLINE_VISIBILITY
+priority_queue<_Tp, _Container, _Compare>::priority_queue(priority_queue&& __q)
+    : c(_STD::move(__q.c)),
+      comp(_STD::move(__q.comp))
+{
+}
+
+template <class _Tp, class _Container, class _Compare>
+priority_queue<_Tp, _Container, _Compare>&
+priority_queue<_Tp, _Container, _Compare>::operator=(priority_queue&& __q)
+{
+    c = _STD::move(__q.c);
+    comp = _STD::move(__q.comp);
+    return *this;
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -589,7 +541,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const value_compare& _
    : c(__c, __a),
      comp(__comp)
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 template <class _Tp, class _Container, class _Compare>
@@ -602,7 +554,7 @@ priority_queue<_Tp, _Container, _Compare>::priority_queue(const priority_queue&
    : c(__q.c, __a),
      comp(__q.comp)
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -615,10 +567,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(_VSTD::move(__c), __a),
+    : c(_STD::move(__c), __a),
      comp(__comp)
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 template <class _Tp, class _Container, class _Compare>
@@ -628,10 +580,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(_VSTD::move(__q.c), __a),
-      comp(_VSTD::move(__q.comp))
+    : c(_STD::move(__q.c), __a),
+      comp(_STD::move(__q.comp))
 {
-    _VSTD::make_heap(c.begin(), c.end(), comp);
+    _STD::make_heap(c.begin(), c.end(), comp);
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -642,7 +594,7 @@ void
 priority_queue<_Tp, _Container, _Compare>::push(const value_type& __v)
 {
    c.push_back(__v);
-    _VSTD::push_heap(c.begin(), c.end(), comp);
+    _STD::push_heap(c.begin(), c.end(), comp);
 }

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -652,8 +604,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::push(value_type&& __v)
 {
-    c.push_back(_VSTD::move(__v));
-    _VSTD::push_heap(c.begin(), c.end(), comp);
+    c.push_back(_STD::move(__v));
+    _STD::push_heap(c.begin(), c.end(), comp);
 }

 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -664,8 +616,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::emplace(_Args&&... __args)
 {
-    c.emplace_back(_VSTD::forward<_Args>(__args)...);
-    _VSTD::push_heap(c.begin(), c.end(), comp);
+    c.emplace_back(_STD::forward<_Args>(__args)...);
+    _STD::push_heap(c.begin(), c.end(), comp);
 }

 #endif  // _LIBCPP_HAS_NO_VARIADICS
@@ -676,7 +628,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::pop()
 {
-    _VSTD::pop_heap(c.begin(), c.end(), comp);
+    _STD::pop_heap(c.begin(), c.end(), comp);
    c.pop_back();
 }

@@ -684,10 +636,8 @@ template <class _Tp, class _Container, class _Compare>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 priority_queue<_Tp, _Container, _Compare>::swap(priority_queue& __q)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value &&
-                   __is_nothrow_swappable<value_compare>::value)
 {
-    using _VSTD::swap;
+    using _STD::swap;
    swap(c, __q.c);
    swap(comp, __q.comp);
 }
@@ -697,7 +647,6 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(priority_queue<_Tp, _Container, _Compare>& __x,
     priority_queue<_Tp, _Container, _Compare>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
--- a/include/random
+++ b/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 _VSTD::equal(__x.__x_, __x.__x_ + _N, __y.__x_);
+        return _STD::equal(__x.__x_, __x.__x_ + _N, __y.__x_);
    if (__x.__i_ == 0 || __y.__i_ == 0)
    {
-        size_t __j = _VSTD::min(_N - __x.__i_, _N - __y.__i_);
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
+        size_t __j = _STD::min(_N - __x.__i_, _N - __y.__i_);
+        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
                         __y.__x_ + __y.__i_))
            return false;
        if (__x.__i_ == 0)
-            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _N, __y.__x_);
-        return _VSTD::equal(__x.__x_, __x.__x_ + (_N - __j), __y.__x_ + __j);
+            return _STD::equal(__x.__x_ + __j, __x.__x_ + _N, __y.__x_);
+        return _STD::equal(__x.__x_, __x.__x_ + (_N - __j), __y.__x_ + __j);
    }
    if (__x.__i_ < __y.__i_)
    {
        size_t __j = _N - __y.__i_;
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
+        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
                         __y.__x_ + __y.__i_))
            return false;
-        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _N,
+        if (!_STD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _N,
                         __y.__x_))
            return false;
-        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
+        return _STD::equal(__x.__x_, __x.__x_ + __x.__i_,
                           __y.__x_ + (_N - (__x.__i_ + __j)));
    }
    size_t __j = _N - __x.__i_;
-    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
+    if (!_STD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
                     __x.__x_ + __x.__i_))
        return false;
-    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _N,
+    if (!_STD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _N,
                     __x.__x_))
        return false;
-    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
+    return _STD::equal(__y.__x_, __y.__x_ + __y.__i_,
                       __x.__x_ + (_N - (__y.__i_ + __j)));
 }

@@ -2562,11 +2562,8 @@ subtract_with_carry_engine<_UIntType, __w, __s, __r>::seed(result_type __sd,
    linear_congruential_engine<result_type, 40014u, 0u, 2147483563u>
        __e(__sd == 0u ? default_seed : __sd);
    for (size_t __i = 0; __i < __r; ++__i)
-    {
-        result_type __e0 = __e();
        __x_[__i] = static_cast<result_type>(
-                                    (__e0 + ((uint64_t)__e() << 32)) & _Max);
-    }
+                                    (__e() + ((uint64_t)__e() << 32)) & _Max);
    __c_ = __x_[__r-1] == 0;
    __i_ = 0;
 }
@@ -2624,37 +2621,37 @@ operator==(
    if (__x.__c_ != __y.__c_)
        return false;
    if (__x.__i_ == __y.__i_)
-        return _VSTD::equal(__x.__x_, __x.__x_ + _R, __y.__x_);
+        return _STD::equal(__x.__x_, __x.__x_ + _R, __y.__x_);
    if (__x.__i_ == 0 || __y.__i_ == 0)
    {
-        size_t __j = _VSTD::min(_R - __x.__i_, _R - __y.__i_);
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
+        size_t __j = _STD::min(_R - __x.__i_, _R - __y.__i_);
+        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + __x.__i_ + __j,
                         __y.__x_ + __y.__i_))
            return false;
        if (__x.__i_ == 0)
-            return _VSTD::equal(__x.__x_ + __j, __x.__x_ + _R, __y.__x_);
-        return _VSTD::equal(__x.__x_, __x.__x_ + (_R - __j), __y.__x_ + __j);
+            return _STD::equal(__x.__x_ + __j, __x.__x_ + _R, __y.__x_);
+        return _STD::equal(__x.__x_, __x.__x_ + (_R - __j), __y.__x_ + __j);
    }
    if (__x.__i_ < __y.__i_)
    {
        size_t __j = _R - __y.__i_;
-        if (!_VSTD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
+        if (!_STD::equal(__x.__x_ + __x.__i_, __x.__x_ + (__x.__i_ + __j),
                         __y.__x_ + __y.__i_))
            return false;
-        if (!_VSTD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _R,
+        if (!_STD::equal(__x.__x_ + (__x.__i_ + __j), __x.__x_ + _R,
                         __y.__x_))
            return false;
-        return _VSTD::equal(__x.__x_, __x.__x_ + __x.__i_,
+        return _STD::equal(__x.__x_, __x.__x_ + __x.__i_,
                           __y.__x_ + (_R - (__x.__i_ + __j)));
    }
    size_t __j = _R - __x.__i_;
-    if (!_VSTD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
+    if (!_STD::equal(__y.__x_ + __y.__i_, __y.__x_ + (__y.__i_ + __j),
                     __x.__x_ + __x.__i_))
        return false;
-    if (!_VSTD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _R,
+    if (!_STD::equal(__y.__x_ + (__y.__i_ + __j), __y.__x_ + _R,
                     __x.__x_))
        return false;
-    return _VSTD::equal(__y.__x_, __y.__x_ + __y.__i_,
+    return _STD::equal(__y.__x_, __y.__x_ + __y.__i_,
                       __x.__x_ + (_R - (__y.__i_ + __j)));
 }

@@ -2747,7 +2744,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit discard_block_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)), __n_(0) {}
+        : __e_(_STD::move(__e)), __n_(0) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit discard_block_engine(result_type __sd) : __e_(__sd), __n_(0) {}
@@ -2947,7 +2944,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit independent_bits_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)) {}
+        : __e_(_STD::move(__e)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit independent_bits_engine(result_type __sd) : __e_(__sd) {}
@@ -3170,7 +3167,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit shuffle_order_engine(_Engine&& __e)
-        : __e_(_VSTD::move(__e)) {__init();}
+        : __e_(_STD::move(__e)) {__init();}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit shuffle_order_engine(result_type __sd) : __e_(__sd) {__init();}
@@ -3295,7 +3292,7 @@ operator==(
    const shuffle_order_engine<_Eng, _K>& __x,
    const shuffle_order_engine<_Eng, _K>& __y)
 {
-    return __x._Y_ == __y._Y_ && _VSTD::equal(__x._V_, __x._V_ + _K, __y._V_) &&
+    return __x._Y_ == __y._Y_ && _STD::equal(__x._V_, __x._V_ + _K, __y._V_) &&
           __x.__e_ == __y.__e_;
 }

@@ -3402,11 +3399,9 @@ public:
    // constructors
    _LIBCPP_INLINE_VISIBILITY
    seed_seq() {}
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    template<class _Tp>
        _LIBCPP_INLINE_VISIBILITY
        seed_seq(initializer_list<_Tp> __il) {init(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    template<class _InputIterator>
        _LIBCPP_INLINE_VISIBILITY
@@ -3423,7 +3418,7 @@ public:
    template<class _OutputIterator>
        _LIBCPP_INLINE_VISIBILITY
        void param(_OutputIterator __dest) const
-            {_VSTD::copy(__v_.begin(), __v_.end(), __dest);}
+            {_STD::copy(__v_.begin(), __v_.end(), __dest);}

 private:
    // no copy functions
@@ -3448,7 +3443,7 @@ seed_seq::generate(_RandomAccessIterator __first, _RandomAccessIterator __last)
 {
    if (__first != __last)
    {
-        _VSTD::fill(__first, __last, 0x8b8b8b8b);
+        _STD::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
@@ -3458,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 = _VSTD::max(__s + 1, __n);
+        const size_t __m = _STD::max(__s + 1, __n);
        // __k = 0;
        {
            result_type __r = 1664525 * _T(__first[0] ^ __first[__p]
@@ -3644,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())
-        * _VSTD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
+        * _STD::generate_canonical<_RealType, numeric_limits<_RealType>::digits>(__g)
        + __p.a();
 }

@@ -3876,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_ = _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_));
+        __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_));
        __odds_ratio_ = __p_ / (1 - __p_);
    }
 }
@@ -4030,10 +4025,10 @@ template<class _URNG>
 _RealType
 exponential_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
-    return -_VSTD::log
+    return -_STD::log
                  (
                      result_type(1) -
-                      _VSTD::generate_canonical<result_type,
+                      _STD::generate_canonical<result_type,
                                       numeric_limits<result_type>::digits>(__g)
                  )
                  / __p.lambda();
@@ -4185,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 = _VSTD::sqrt(-2 * _VSTD::log(__s) / __s);
+        result_type _F = _STD::sqrt(-2 * _STD::log(__s) / __s);
        _V_ = __v * _F;
        _V_hot_ = true;
        _U = __u * _F;
@@ -4302,7 +4297,7 @@ public:
    template<class _URNG>
        _LIBCPP_INLINE_VISIBILITY
        result_type operator()(_URNG& __g, const param_type& __p)
-        {return _VSTD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}
+        {return _STD::exp(const_cast<normal_distribution<result_type>&>(__p.__nd_)(__g));}

    // property functions
    _LIBCPP_INLINE_VISIBILITY
@@ -4451,7 +4446,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
    {
        __s_ = 0;
        __d_ = 0;
-        __l_ = _VSTD::exp(-__mean_);
+        __l_ = _STD::exp(-__mean_);
        __omega_ = 0;
        __c3_ = 0;
        __c2_ = 0;
@@ -4461,7 +4456,7 @@ poisson_distribution<_IntType>::param_type::param_type(double __mean)
    }
    else
    {
-        __s_ = _VSTD::sqrt(__mean_);
+        __s_ = _STD::sqrt(__mean_);
        __d_ = 6 * __mean_ * __mean_;
        __l_ = static_cast<result_type>(__mean_ - 1.1484);
        __omega_ = .3989423 / __s_;
@@ -4528,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 = _VSTD::pow(__pr.__mean_, (double)__x) / __fac[__x];
+                __py = _STD::pow(__pr.__mean_, (double)__x) / __fac[__x];
            }
            else
            {
                double __del = .8333333E-1 / __x;
                __del -= 4.8 * __del * __del * __del;
                double __v = __difmuk / __x;
-                if (_VSTD::abs(__v) > 0.25)
-                    __px = __x * _VSTD::log(1 + __v) - __difmuk - __del;
+                if (_STD::abs(__v) > 0.25)
+                    __px = __x * _STD::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 / _VSTD::sqrt(__x);
+                __py = .3989423 / _STD::sqrt(__x);
            }
            double __r = (0.5 - __difmuk) / __pr.__s_;
            double __r2 = __r * __r;
@@ -4550,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_ * _VSTD::abs(__u) <= __py * _VSTD::exp(__px + __e) -
-                                                   __fy * _VSTD::exp(__fx + __e))
+                if (__pr.__c_ * _STD::abs(__u) <= __py * _STD::exp(__px + __e) -
+                                                   __fy * _STD::exp(__fx + __e))
                    break;
            }
            else
            {
-                if (__fy - __u * __fy <= __py * _VSTD::exp(__px - __fx))
+                if (__fy - __u * __fy <= __py * _STD::exp(__px - __fx))
                    break;
            }
        }
@@ -4647,7 +4642,7 @@ public:
        _LIBCPP_INLINE_VISIBILITY
        result_type operator()(_URNG& __g, const param_type& __p)
        {return __p.b() *
-            _VSTD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}
+            _STD::pow(exponential_distribution<result_type>()(__g), 1/__p.a());}

    // property functions
    _LIBCPP_INLINE_VISIBILITY
@@ -4791,7 +4786,7 @@ _RealType
 extreme_value_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
 {
    return __p.a() - __p.b() *
-         _VSTD::log(-_VSTD::log(1-uniform_real_distribution<result_type>()(__g)));
+         _STD::log(-_STD::log(1-uniform_real_distribution<result_type>()(__g)));
 }

 template <class _CharT, class _Traits, class _RT>
@@ -4928,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 = _VSTD::sqrt(__c / __w) *
+                const result_type __y = _STD::sqrt(__c / __w) *
                                        (__u - result_type(0.5));
                __x = __b + __y;
                if (__x >= 0)
@@ -4936,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 (_VSTD::log(__z) <= 2 * (__b * _VSTD::log(__x / __b) - __y))
+                    if (_STD::log(__z) <= 2 * (__b * _STD::log(__x / __b) - __y))
                        break;
                }
            }
@@ -4950,14 +4945,14 @@ gamma_distribution<_RealType>::operator()(_URNG& __g, const param_type& __p)
            const result_type __es = __egen(__g);
            if (__u <= 1 - __a)
            {
-                __x = _VSTD::pow(__u, 1 / __a);
+                __x = _STD::pow(__u, 1 / __a);
                if (__x <= __es)
                    break;
            }
            else
            {
-                const result_type __e = -_VSTD::log((1-__u)/__a);
-                __x = _VSTD::pow(1 - __a + __a * __e, 1 / __a);
+                const result_type __e = -_STD::log((1-__u)/__a);
+                __x = _STD::pow(1 - __a + __a * __e, 1 / __a);
                if (__x <= __e + __es)
                    break;
            }
@@ -5429,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() * _VSTD::tan(3.1415926535897932384626433832795 * __gen(__g));
+    return __p.a() + __p.b() * _STD::tan(3.1415926535897932384626433832795 * __gen(__g));
 }

 template <class _CharT, class _Traits, class _RT>
@@ -5667,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) * _VSTD::sqrt(__p.n()/__gd(__g));
+    return __nd_(__g) * _STD::sqrt(__p.n()/__gd(__g));
 }

 template <class _CharT, class _Traits, class _RT>
@@ -5720,11 +5715,9 @@ public:
            _LIBCPP_INLINE_VISIBILITY
            param_type(_InputIterator __f, _InputIterator __l)
            : __p_(__f, __l) {__init();}
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
        _LIBCPP_INLINE_VISIBILITY
        param_type(initializer_list<double> __wl)
            : __p_(__wl.begin(), __wl.end()) {__init();}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
        template<class _UnaryOperation>
            param_type(size_t __nw, double __xmin, double __xmax,
                       _UnaryOperation __fw);
@@ -5767,11 +5760,9 @@ public:
        _LIBCPP_INLINE_VISIBILITY
        discrete_distribution(_InputIterator __f, _InputIterator __l)
            : __p_(__f, __l) {}
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    discrete_distribution(initializer_list<double> __wl)
        : __p_(__wl) {}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    template<class _UnaryOperation>
        _LIBCPP_INLINE_VISIBILITY
        discrete_distribution(size_t __nw, double __xmin, double __xmax,
@@ -5852,12 +5843,12 @@ discrete_distribution<_IntType>::param_type::__init()
    {
        if (__p_.size() > 1)
        {
-            double __s = _VSTD::accumulate(__p_.begin(), __p_.end(), 0.0);
-            for (_VSTD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
+            double __s = _STD::accumulate(__p_.begin(), __p_.end(), 0.0);
+            for (_STD::vector<double>::iterator __i = __p_.begin(), __e = __p_.end();
                                                                       __i < __e; ++__i)
                *__i /= __s;
            vector<double> __t(__p_.size() - 1);
-            _VSTD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
+            _STD::partial_sum(__p_.begin(), __p_.end() - 1, __t.begin());
            swap(__p_, __t);
        }
        else
@@ -5873,8 +5864,8 @@ vector<double>
 discrete_distribution<_IntType>::param_type::probabilities() const
 {
    size_t __n = __p_.size();
-    _VSTD::vector<double> __p(__n+1);
-    _VSTD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
+    _STD::vector<double> __p(__n+1);
+    _STD::adjacent_difference(__p_.begin(), __p_.end(), __p.begin());
    if (__n > 0)
        __p[__n] = 1 - __p_[__n-1];
    else
@@ -5889,7 +5880,7 @@ discrete_distribution<_IntType>::operator()(_URNG& __g, const param_type& __p)
 {
    uniform_real_distribution<double> __gen;
    return static_cast<_IntType>(
-           _VSTD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
+           _STD::upper_bound(__p.__p_.begin(), __p.__p_.end(), __gen(__g)) -
                                                              __p.__p_.begin());
 }

@@ -5951,10 +5942,8 @@ public:
        template<class _InputIteratorB, class _InputIteratorW>
            param_type(_InputIteratorB __fB, _InputIteratorB __lB,
                       _InputIteratorW __fW);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
        template<class _UnaryOperation>
            param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
        template<class _UnaryOperation>
            param_type(size_t __nw, result_type __xmin, result_type __xmax,
                       _UnaryOperation __fw);
@@ -6004,13 +5993,11 @@ public:
                                        _InputIteratorW __fW)
        : __p_(__fB, __lB, __fW) {}

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    template<class _UnaryOperation>
        _LIBCPP_INLINE_VISIBILITY
        piecewise_constant_distribution(initializer_list<result_type> __bl,
                                        _UnaryOperation __fw)
        : __p_(__bl, __fw) {}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    template<class _UnaryOperation>
        _LIBCPP_INLINE_VISIBILITY
@@ -6092,14 +6079,14 @@ void
 piecewise_constant_distribution<_RealType>::param_type::__init()
 {
    // __densities_ contains non-normalized areas
-    result_type __total_area = _VSTD::accumulate(__densities_.begin(),
+    result_type __total_area = _STD::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());
-    _VSTD::partial_sum(__densities_.begin(), __densities_.end() - 1,
+    _STD::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
@@ -6140,8 +6127,6 @@ piecewise_constant_distribution<_RealType>::param_type::param_type(
    }
 }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template<class _RealType>
 template<class _UnaryOperation>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
@@ -6165,8 +6150,6 @@ piecewise_constant_distribution<_RealType>::param_type::param_type(
    }
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template<class _RealType>
 template<class _UnaryOperation>
 piecewise_constant_distribution<_RealType>::param_type::param_type(
@@ -6192,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 = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
+    ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                      __u) - __p.__areas_.begin() - 1;
    return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
 }
@@ -6275,10 +6258,8 @@ public:
        template<class _InputIteratorB, class _InputIteratorW>
            param_type(_InputIteratorB __fB, _InputIteratorB __lB,
                       _InputIteratorW __fW);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
        template<class _UnaryOperation>
            param_type(initializer_list<result_type> __bl, _UnaryOperation __fw);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
        template<class _UnaryOperation>
            param_type(size_t __nw, result_type __xmin, result_type __xmax,
                       _UnaryOperation __fw);
@@ -6328,13 +6309,11 @@ public:
                                      _InputIteratorW __fW)
        : __p_(__fB, __lB, __fW) {}

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    template<class _UnaryOperation>
        _LIBCPP_INLINE_VISIBILITY
        piecewise_linear_distribution(initializer_list<result_type> __bl,
                                      _UnaryOperation __fw)
        : __p_(__bl, __fw) {}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    template<class _UnaryOperation>
        _LIBCPP_INLINE_VISIBILITY
@@ -6468,8 +6447,6 @@ piecewise_linear_distribution<_RealType>::param_type::param_type(
    }
 }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template<class _RealType>
 template<class _UnaryOperation>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
@@ -6493,8 +6470,6 @@ piecewise_linear_distribution<_RealType>::param_type::param_type(
    }
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template<class _RealType>
 template<class _UnaryOperation>
 piecewise_linear_distribution<_RealType>::param_type::param_type(
@@ -6521,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 = _VSTD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
+    ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
                                      __u) - __p.__areas_.begin() - 1;
    __u -= __p.__areas_[__k];
    const result_type __dk = __p.__densities_[__k];
@@ -6533,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 +
-        _VSTD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
+        _STD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
        __deltad;
 }

--- a/include/ratio
+++ b/include/ratio
@@ -274,19 +274,10 @@ public:
        >::type type;
 };

-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_multiply
-                                    = typename __ratio_multiply<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct _LIBCPP_VISIBLE ratio_multiply
    : public __ratio_multiply<_R1, _R2>::type {};

-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct __ratio_divide
 {
@@ -301,19 +292,10 @@ public:
        >::type type;
 };

-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_divide
-                                      = typename __ratio_divide<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct _LIBCPP_VISIBLE ratio_divide
    : public __ratio_divide<_R1, _R2>::type {};

-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct __ratio_add
 {
@@ -336,19 +318,10 @@ public:
        >::type type;
 };

-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_add
-                                         = typename __ratio_add<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct _LIBCPP_VISIBLE ratio_add
    : public __ratio_add<_R1, _R2>::type {};

-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct __ratio_subtract
 {
@@ -371,19 +344,10 @@ public:
        >::type type;
 };

-#ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
-template <class _R1, class _R2> using ratio_subtract
-                                    = typename __ratio_subtract<_R1, _R2>::type;
-
-#else  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 template <class _R1, class _R2>
 struct _LIBCPP_VISIBLE ratio_subtract
    : public __ratio_subtract<_R1, _R2>::type {};

-#endif  // _LIBCPP_HAS_NO_TEMPLATE_ALIASES
-
 // ratio_equal

 template <class _R1, class _R2>
--- a/include/regex
+++ b/include/regex
@@ -1280,7 +1280,7 @@ class __node
    __node(const __node&);
    __node& operator=(const __node&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef _STD::__state<_CharT> __state;

    _LIBCPP_INLINE_VISIBILITY
    __node() {}
@@ -1300,7 +1300,7 @@ class __end_state
    : public __node<_CharT>
 {
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef _STD::__state<_CharT> __state;

    _LIBCPP_INLINE_VISIBILITY
    __end_state() {}
@@ -1365,7 +1365,7 @@ class __empty_state
    typedef __owns_one_state<_CharT> base;

 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__state<_CharT> __state;

    _LIBCPP_INLINE_VISIBILITY
    explicit __repeat_one_loop(__node<_CharT>* __s)
@@ -1479,7 +1479,7 @@ class __loop
    bool __greedy_;

 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 &&
-            _VSTD::equal(__sm.first, __sm.second, __s.__current_))
+            _STD::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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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 _VSTD::__state<_CharT> __state;
+    typedef _STD::__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(_VSTD::move(__b), _VSTD::move(__e)));
+                __ranges_.push_back(make_pair(_STD::move(__b), _STD::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 = _VSTD::next(__s.__current_);
+            const _CharT* __next = _STD::next(__s.__current_);
            if (__next != __s.__last_)
            {
                pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
@@ -2410,7 +2410,7 @@ __exit:
    }
 }

-template <class _CharT, class _Traits> class __lookahead;
+template <class, class> 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 _VSTD::__state<_CharT> __state;
-    typedef _VSTD::__node<_CharT> __node;
+    typedef _STD::__state<_CharT> __state;
+    typedef _STD::__node<_CharT> __node;

 public:
    // constants:
@@ -2478,14 +2478,12 @@ public:
        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
          __end_(0)
        {__parse(__first, __last);}
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    basic_regex(initializer_list<value_type> __il,
                flag_type __f = regex_constants::ECMAScript)
        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
          __end_(0)
        {__parse(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

 //    ~basic_regex() = default;

@@ -2494,11 +2492,9 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    basic_regex& operator=(const value_type* __p)
        {return assign(__p);}
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    basic_regex& operator=(initializer_list<value_type> __il)
        {return assign(__il);}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    template <class _ST, class _SA>
        _LIBCPP_INLINE_VISIBILITY
        basic_regex& operator=(const basic_string<value_type, _ST, _SA>& __p)
@@ -2561,15 +2557,11 @@ public:
            __parse(__first, __last);
        }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
    _LIBCPP_INLINE_VISIBILITY
    basic_regex& assign(initializer_list<value_type> __il,
                        flag_type __f = regex_constants::ECMAScript)
        {return assign(__il.begin(), __il.end(), __f);}

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
    // const operations:
    _LIBCPP_INLINE_VISIBILITY
    unsigned mark_count() const {return __marked_count_;}
@@ -2842,7 +2834,7 @@ template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
 {
-    using _VSTD::swap;
+    using _STD::swap;
    swap(__traits_, __r.__traits_);
    swap(__flags_, __r.__flags_);
    swap(__marked_count_, __r.__marked_count_);
@@ -2874,7 +2866,7 @@ class __lookahead
    __lookahead(const __lookahead&);
    __lookahead& operator=(const __lookahead&);
 public:
-    typedef _VSTD::__state<_CharT> __state;
+    typedef _STD::__state<_CharT> __state;

    _LIBCPP_INLINE_VISIBILITY
    __lookahead(const basic_regex<_CharT, _Traits>& __exp, bool __invert, __node<_CharT>* __s)
@@ -2961,7 +2953,7 @@ basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
            __first = __parse_RE_expression(__first, __last);
            if (__first != __last)
            {
-                _ForwardIterator __temp = _VSTD::next(__first);
+                _ForwardIterator __temp = _STD::next(__first);
                if (__temp == __last && *__first == '$')
                {
                    __push_r_anchor();
@@ -3190,7 +3182,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '(')
@@ -3208,7 +3200,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == ')')
@@ -3226,7 +3218,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '{')
@@ -3244,7 +3236,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '}')
@@ -3262,7 +3254,7 @@ basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && '1' <= *__temp && *__temp <= '9')
@@ -3283,7 +3275,7 @@ basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp == __last && *__first == '$')
            return __first;
        // Not called inside a bracket
@@ -3341,7 +3333,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\')
@@ -3372,7 +3364,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\')
@@ -3682,7 +3674,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
 {
    if (__first != __last && *__first != ']')
    {
-        _ForwardIterator __temp = _VSTD::next(__first);
+        _ForwardIterator __temp = _STD::next(__first);
        basic_string<_CharT> __start_range;
        if (__temp != __last && *__first == '[')
        {
@@ -3711,7 +3703,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
        }
        if (__first != __last && *__first != ']')
        {
-            __temp = _VSTD::next(__first);
+            __temp = _STD::next(__first);
            if (__temp != __last && *__first == '-' && *__temp != ']')
            {
                // parse a range
@@ -3737,7 +3729,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
                        ++__first;
                    }
                }
-                __ml->__add_range(_VSTD::move(__start_range), _VSTD::move(__end_range));
+                __ml->__add_range(_STD::move(__start_range), _STD::move(__end_range));
            }
            else
            {
@@ -3898,7 +3890,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
    // Found [=
    //   This means =] must exist
    value_type _Equal_close[2] = {'=', ']'};
-    _ForwardIterator __temp = _VSTD::search(__first, __last, _Equal_close,
+    _ForwardIterator __temp = _STD::search(__first, __last, _Equal_close,
                                                            _Equal_close+2);
 #ifndef _LIBCPP_NO_EXCEPTIONS
    if (__temp == __last)
@@ -3933,7 +3925,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
 #endif  // _LIBCPP_NO_EXCEPTIONS
        }
    }
-    __first = _VSTD::next(__temp, 2);
+    __first = _STD::next(__temp, 2);
    return __first;
 }

@@ -3947,7 +3939,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
    // Found [:
    //   This means :] must exist
    value_type _Colon_close[2] = {':', ']'};
-    _ForwardIterator __temp = _VSTD::search(__first, __last, _Colon_close,
+    _ForwardIterator __temp = _STD::search(__first, __last, _Colon_close,
                                                            _Colon_close+2);
 #ifndef _LIBCPP_NO_EXCEPTIONS
    if (__temp == __last)
@@ -3962,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 = _VSTD::next(__temp, 2);
+    __first = _STD::next(__temp, 2);
    return __first;
 }

@@ -3976,7 +3968,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
    // Found [.
    //   This means .] must exist
    value_type _Dot_close[2] = {'.', ']'};
-    _ForwardIterator __temp = _VSTD::search(__first, __last, _Dot_close,
+    _ForwardIterator __temp = _STD::search(__first, __last, _Dot_close,
                                                            _Dot_close+2);
 #ifndef _LIBCPP_NO_EXCEPTIONS
    if (__temp == __last)
@@ -3995,7 +3987,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
        throw regex_error(regex_constants::error_collate);
 #endif  // _LIBCPP_NO_EXCEPTIONS
    }
-    __first = _VSTD::next(__temp, 2);
+    __first = _STD::next(__temp, 2);
    return __first;
 }

@@ -4099,7 +4091,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
            break;
        case '\\':
            {
-                _ForwardIterator __temp = _VSTD::next(__first);
+                _ForwardIterator __temp = _STD::next(__first);
                if (__temp != __last)
                {
                    if (*__temp == 'b')
@@ -4117,7 +4109,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
            break;
        case '(':
            {
-                _ForwardIterator __temp = _VSTD::next(__first);
+                _ForwardIterator __temp = _STD::next(__first);
                if (__temp != __last && *__temp == '?')
                {
                    if (++__temp != __last)
@@ -4129,7 +4121,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                basic_regex __exp;
                                __exp.__flags_ = __flags_;
                                __temp = __exp.__parse(++__temp, __last);
-                                __push_lookahead(_VSTD::move(__exp), false);
+                                __push_lookahead(_STD::move(__exp), false);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                if (__temp == __last || *__temp != ')')
                                    throw regex_error(regex_constants::error_paren);
@@ -4142,7 +4134,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                basic_regex __exp;
                                __exp.__flags_ = __flags_;
                                __temp = __exp.__parse(++__temp, __last);
-                                __push_lookahead(_VSTD::move(__exp), true);
+                                __push_lookahead(_STD::move(__exp), true);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                if (__temp == __last || *__temp != ')')
                                    throw regex_error(regex_constants::error_paren);
@@ -4187,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 = _VSTD::next(__first);
+                _ForwardIterator __temp = _STD::next(__first);
                if (__temp != __last && *__first == '?' && *__temp == ':')
                {
                    ++__open_count_;
@@ -4231,7 +4223,7 @@ basic_regex<_CharT, _Traits>::__parse_atom_escape(_ForwardIterator __first,
 {
    if (__first != __last && *__first == '\\')
    {
-        _ForwardIterator __t1 = _VSTD::next(__first);
+        _ForwardIterator __t1 = _STD::next(__first);
        _ForwardIterator __t2 = __parse_decimal_escape(__t1, __last);
        if (__t2 != __t1)
            __first = __t2;
@@ -4377,7 +4369,7 @@ basic_regex<_CharT, _Traits>::__parse_character_escape(_ForwardIterator __first,
            ++__first;
            break;
        case 'c':
-            if ((__t = _VSTD::next(__first)) != __last)
+            if ((__t = _STD::next(__first)) != __last)
            {
                if ('A' <= *__t <= 'Z' || 'a' <= *__t <= 'z')
                {
@@ -4502,7 +4494,7 @@ basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
                                           _ForwardIterator __last)
 {
    __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
+    _ForwardIterator __t1 = _STD::find(__first, __last, _CharT('\n'));
    if (__t1 != __first)
        __parse_basic_reg_exp(__first, __t1);
    else
@@ -4512,7 +4504,7 @@ basic_regex<_CharT, _Traits>::__parse_grep(_ForwardIterator __first,
        ++__first;
    while (__first != __last)
    {
-        __t1 = _VSTD::find(__first, __last, _CharT('\n'));
+        __t1 = _STD::find(__first, __last, _CharT('\n'));
        __owns_one_state<_CharT>* __sb = __end_;
        if (__t1 != __first)
            __parse_basic_reg_exp(__first, __t1);
@@ -4533,7 +4525,7 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
                                            _ForwardIterator __last)
 {
    __owns_one_state<_CharT>* __sa = __end_;
-    _ForwardIterator __t1 = _VSTD::find(__first, __last, _CharT('\n'));
+    _ForwardIterator __t1 = _STD::find(__first, __last, _CharT('\n'));
    if (__t1 != __first)
        __parse_extended_reg_exp(__first, __t1);
    else
@@ -4543,7 +4535,7 @@ basic_regex<_CharT, _Traits>::__parse_egrep(_ForwardIterator __first,
        ++__first;
    while (__first != __last)
    {
-        __t1 = _VSTD::find(__first, __last, _CharT('\n'));
+        __t1 = _STD::find(__first, __last, _CharT('\n'));
        __owns_one_state<_CharT>* __sb = __end_;
        if (__t1 != __first)
            __parse_extended_reg_exp(__first, __t1);
@@ -4740,7 +4732,7 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    difference_type length() const
-        {return matched ? _VSTD::distance(this->first, this->second) : 0;}
+        {return matched ? _STD::distance(this->first, this->second) : 0;}
    _LIBCPP_INLINE_VISIBILITY
    string_type str() const
        {return matched ? string_type(this->first, this->second) : string_type();}
@@ -5196,7 +5188,7 @@ public:
        {return (*this)[__sub].length();}
    _LIBCPP_INLINE_VISIBILITY
    difference_type position(size_type __sub = 0) const
-        {return _VSTD::distance(__position_start_, (*this)[__sub].first);}
+        {return _STD::distance(__position_start_, (*this)[__sub].first);}
    _LIBCPP_INLINE_VISIBILITY
    string_type str(size_type __sub = 0) const
        {return (*this)[__sub].str();}
@@ -5210,11 +5202,11 @@ public:
    const_reference suffix() const {return __suffix_;}

    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin();}
+    const_iterator begin() const {return empty() ? __matches_.end() : __matches_.begin() + 1;}
    _LIBCPP_INLINE_VISIBILITY
    const_iterator end() const {return __matches_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin();}
+    const_iterator cbegin() const {return empty() ? __matches_.end() : __matches_.begin() + 1;}
    _LIBCPP_INLINE_VISIBILITY
    const_iterator cend() const {return __matches_.end();}

@@ -5268,18 +5260,18 @@ public:
        __matches_.resize(__m.size());
        for (size_type __i = 0; __i < __matches_.size(); ++__i)
        {
-            __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].first = _STD::next(__f, _STD::distance(__mf, __m[__i].first));
+            __matches_[__i].second = _STD::next(__f, _STD::distance(__mf, __m[__i].second));
            __matches_[__i].matched = __m[__i].matched;
        }
        __unmatched_.first   = __l;
        __unmatched_.second  = __l;
        __unmatched_.matched = false;
-        __prefix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().first));
-        __prefix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.prefix().second));
+        __prefix_.first = _STD::next(__f, _STD::distance(__mf, __m.prefix().first));
+        __prefix_.second = _STD::next(__f, _STD::distance(__mf, __m.prefix().second));
        __prefix_.matched = __m.prefix().matched;
-        __suffix_.first = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().first));
-        __suffix_.second = _VSTD::next(__f, _VSTD::distance(__mf, __m.suffix().second));
+        __suffix_.first = _STD::next(__f, _STD::distance(__mf, __m.suffix().first));
+        __suffix_.second = _STD::next(__f, _STD::distance(__mf, __m.suffix().second));
        __suffix_.matched = __m.suffix().matched;
        if (!__no_update_pos)
            __position_start_ = __prefix_.first;
@@ -5350,7 +5342,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
        for (; __fmt_first != __fmt_last; ++__fmt_first)
        {
            if (*__fmt_first == '&')
-                __out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
+                __out = _STD::copy(__matches_[0].first, __matches_[0].second,
                                   __out);
            else if (*__fmt_first == '\\' && __fmt_first + 1 != __fmt_last)
            {
@@ -5358,7 +5350,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
                if ('0' <= *__fmt_first && *__fmt_first <= '9')
                {
                    size_t __i = *__fmt_first - '0';
-                    __out = _VSTD::copy(__matches_[__i].first,
+                    __out = _STD::copy(__matches_[__i].first,
                                       __matches_[__i].second, __out);
                }
                else
@@ -5388,16 +5380,16 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
                    break;
                case '&':
                    ++__fmt_first;
-                    __out = _VSTD::copy(__matches_[0].first, __matches_[0].second,
+                    __out = _STD::copy(__matches_[0].first, __matches_[0].second,
                                       __out);
                    break;
                case '`':
                    ++__fmt_first;
-                    __out = _VSTD::copy(__prefix_.first, __prefix_.second, __out);
+                    __out = _STD::copy(__prefix_.first, __prefix_.second, __out);
                    break;
                case '\'':
                    ++__fmt_first;
-                    __out = _VSTD::copy(__suffix_.first, __suffix_.second, __out);
+                    __out = _STD::copy(__suffix_.first, __suffix_.second, __out);
                    break;
                default:
                    if ('0' <= __fmt_first[1] && __fmt_first[1] <= '9')
@@ -5410,7 +5402,7 @@ match_results<_BidirectionalIterator, _Allocator>::format(_OutputIter __out,
                            ++__fmt_first;
                            __i = 10 * __i + *__fmt_first - '0';
                        }
-                        __out = _VSTD::copy(__matches_[__i].first,
+                        __out = _STD::copy(__matches_[__i].first,
                                           __matches_[__i].second, __out);
                    }
                    else
@@ -5435,7 +5427,7 @@ template <class _BidirectionalIterator, class _Allocator>
 void
 match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
 {
-    using _VSTD::swap;
+    using _STD::swap;
    swap(__matches_, __m.__matches_);
    swap(__unmatched_, __m.__unmatched_);
    swap(__prefix_, __m.__prefix_);
@@ -5493,7 +5485,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
 {
    vector<__state> __states;
    ptrdiff_t __j = 0;
-    ptrdiff_t _N = _VSTD::distance(__first, __last);
+    ptrdiff_t _N = _STD::distance(__first, __last);
    __node* __st = __start_.get();
    if (__st)
    {
@@ -5517,7 +5509,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
            {
            case __state::__end_state:
                __m.__matches_[0].first = __first;
-                __m.__matches_[0].second = _VSTD::next(__first, __s.__current_ - __first);
+                __m.__matches_[0].second = _STD::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];
@@ -5531,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(_VSTD::move(__snext));
+                __states.push_back(_STD::move(__snext));
                }
                break;
            case __state::__reject:
@@ -5559,7 +5551,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
 {
    deque<__state> __states;
    ptrdiff_t __highest_j = 0;
-    ptrdiff_t _N = _VSTD::distance(__first, __last);
+    ptrdiff_t _N = _STD::distance(__first, __last);
    __node* __st = __start_.get();
    if (__st)
    {
@@ -5592,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(_VSTD::move(__s));
+                __states.push_front(_STD::move(__s));
                __states.pop_back();
                break;
            case __state::__repeat:
@@ -5603,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(_VSTD::move(__snext));
+                __states.push_back(_STD::move(__snext));
                }
                break;
            case __state::__reject:
@@ -5619,7 +5611,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
        if (__matched)
        {
            __m.__matches_[0].first = __first;
-            __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
+            __m.__matches_[0].second = _STD::next(__first, __highest_j);
            __m.__matches_[0].matched = true;
            return true;
        }
@@ -5639,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 = _VSTD::distance(__first, __last);
+    ptrdiff_t _N = _STD::distance(__first, __last);
    __node* __st = __start_.get();
    if (__st)
    {
@@ -5686,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(_VSTD::move(__snext));
+                __states.push_back(_STD::move(__snext));
                }
                break;
            case __state::__reject:
@@ -5702,7 +5694,7 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
        if (__matched)
        {
            __m.__matches_[0].first = __first;
-            __m.__matches_[0].second = _VSTD::next(__first, __highest_j);
+            __m.__matches_[0].second = _STD::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];
@@ -5832,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 _VSTD::regex_search(__str, __m, __e, __flags);
+    return _STD::regex_search(__str, __m, __e, __flags);
 }

 template <class _ST, class _SA, class _CharT, class _Traits>
@@ -5869,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 = _VSTD::regex_search(__first, __last, __m, __e,
+    bool __r = _STD::regex_search(__first, __last, __m, __e,
                            __flags | regex_constants::match_continuous);
    if (__r)
    {
@@ -5888,7 +5880,7 @@ regex_match(_BidirectionalIterator __first, _BidirectionalIterator __last,
            regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
    match_results<_BidirectionalIterator> __m;
-    return _VSTD::regex_match(__first, __last, __m, __e, __flags);
+    return _STD::regex_match(__first, __last, __m, __e, __flags);
 }

 template <class _CharT, class _Allocator, class _Traits>
@@ -5898,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 _VSTD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
+    return _STD::regex_match(__str, __str + _Traits::length(__str), __m, __e, __flags);
 }

 template <class _ST, class _SA, class _Allocator, class _CharT, class _Traits>
@@ -5909,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 _VSTD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
+    return _STD::regex_match(__s.begin(), __s.end(), __m, __e, __flags);
 }

 template <class _CharT, class _Traits>
@@ -5918,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 _VSTD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
+    return _STD::regex_match(__str, __str + _Traits::length(__str), __e, __flags);
 }

 template <class _ST, class _SA, class _CharT, class _Traits>
@@ -5928,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 _VSTD::regex_match(__s.begin(), __s.end(), __e, __flags);
+    return _STD::regex_match(__s.begin(), __s.end(), __e, __flags);
 }

 // regex_iterator
@@ -5993,7 +5985,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::
      __pregex_(&__re),
      __flags_(__m)
 {
-    _VSTD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
+    _STD::regex_search(__begin_, __end_, __match_, *__pregex_, __flags_);
 }

 template <class _BidirectionalIterator, class _CharT, class _Traits>
@@ -6025,7 +6017,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
            __match_ = value_type();
            return *this;
        }
-        else if (_VSTD::regex_search(__start, __end_, __match_, *__pregex_,
+        else if (_STD::regex_search(__start, __end_, __match_, *__pregex_,
                                    __flags_ | regex_constants::match_not_null |
                                    regex_constants::match_continuous))
            return *this;
@@ -6033,7 +6025,7 @@ regex_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
            ++__start;
    }
    __flags_ |= regex_constants::match_prev_avail;
-    if (!_VSTD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
+    if (!_STD::regex_search(__start, __end_, __match_, *__pregex_, __flags_))
        __match_ = value_type();
    return *this;
 }
@@ -6077,13 +6069,11 @@ public:
                         const regex_type& __re, const vector<int>& __submatches,
                         regex_constants::match_flag_type __m =
                                                regex_constants::match_default);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
                         const regex_type& __re,
                         initializer_list<int> __submatches,
                         regex_constants::match_flag_type __m =
                                                regex_constants::match_default);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    template <size_t _N>
        regex_token_iterator(_BidirectionalIterator __a,
                             _BidirectionalIterator __b,
@@ -6172,8 +6162,6 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
    __init(__a, __b);
 }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
    regex_token_iterator(_BidirectionalIterator __a, _BidirectionalIterator __b,
@@ -6187,8 +6175,6 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
    __init(__a, __b);
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _BidirectionalIterator, class _CharT, class _Traits>
 template <size_t _N>
 regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::
@@ -6281,7 +6267,7 @@ regex_token_iterator<_BidirectionalIterator, _CharT, _Traits>::operator++()
        }
        else
        {
-            if (_VSTD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
+            if (_STD::find(__subs_.begin(), __subs_.end(), -1) != __subs_.end()
                && __prev->suffix().length() != 0)
            {
                __suffix_.matched = true;
@@ -6317,7 +6303,7 @@ regex_replace(_OutputIterator __out,
    if (__i == __eof)
    {
        if (!(__flags & regex_constants::format_no_copy))
-            __out = _VSTD::copy(__first, __last, __out);
+            __out = _STD::copy(__first, __last, __out);
    }
    else
    {
@@ -6325,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 = _VSTD::copy(__i->prefix().first, __i->prefix().second, __out);
+                __out = _STD::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 = _VSTD::copy(__lm.first, __lm.second, __out);
+            __out = _STD::copy(__lm.first, __lm.second, __out);
    }
    return __out;
 }
@@ -6347,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 _VSTD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
+    return _STD::regex_replace(__out, __first, __last, __e, __fmt.c_str(), __flags);
 }

 template <class _Traits, class _CharT, class _ST, class _SA, class _FST,
@@ -6360,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;
-    _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
+    _STD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                        __fmt.c_str(), __flags);
    return __r;
 }
@@ -6373,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;
-    _VSTD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
+    _STD::regex_replace(back_inserter(__r), __s.begin(), __s.end(), __e,
                        __fmt, __flags);
    return __r;
 }
@@ -6387,7 +6373,7 @@ regex_replace(const _CharT* __s,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
    basic_string<_CharT> __r;
-    _VSTD::regex_replace(back_inserter(__r), __s,
+    _STD::regex_replace(back_inserter(__r), __s,
                        __s + char_traits<_CharT>::length(__s), __e,
                        __fmt.c_str(), __flags);
    return __r;
@@ -6402,7 +6388,7 @@ regex_replace(const _CharT* __s,
              regex_constants::match_flag_type __flags = regex_constants::match_default)
 {
    basic_string<_CharT> __r;
-    _VSTD::regex_replace(back_inserter(__r), __s,
+    _STD::regex_replace(back_inserter(__r), __s,
                        __s + char_traits<_CharT>::length(__s), __e,
                        __fmt, __flags);
    return __r;
--- a/include/scoped_allocator
+++ b/include/scoped_allocator
@@ -49,25 +49,24 @@ public:
    scoped_allocator_adaptor();
    template <class OuterA2>
        scoped_allocator_adaptor(OuterA2&& outerAlloc,
-                                 const InnerAllocs&... innerAllocs) noexcept;
-    scoped_allocator_adaptor(const scoped_allocator_adaptor& other) noexcept;
-    scoped_allocator_adaptor(scoped_allocator_adaptor&& other) noexcept;
+                                 const InnerAllocs&... innerAllocs);
+    scoped_allocator_adaptor(const scoped_allocator_adaptor& other);
    template <class OuterA2>
-        scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other) noexcept;
+        scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& other);
    template <class OuterA2>
-        scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other) noexcept;
+        scoped_allocator_adaptor(const scoped_allocator_adaptor<OuterA2, InnerAllocs...>&& other);

    ~scoped_allocator_adaptor();

-    inner_allocator_type& inner_allocator() noexcept;
-    const inner_allocator_type& inner_allocator() const noexcept;
+    inner_allocator_type& inner_allocator();
+    const inner_allocator_type& inner_allocator() const;

-    outer_allocator_type& outer_allocator() noexcept;
-    const outer_allocator_type& outer_allocator() const noexcept;
+    outer_allocator_type& outer_allocator();
+    const outer_allocator_type& outer_allocator() const;

    pointer allocate(size_type n);
    pointer allocate(size_type n, const_void_pointer hint);
-    void deallocate(pointer p, size_type n) noexcept;
+    void deallocate(pointer p, size_type n);

    size_type max_size() const;
    template <class T, class... Args> void construct(T* p, Args&& args);
@@ -84,20 +83,18 @@ public:
        void construct(pair<T1, T2>* p, pair<U, V>&& x);
    template <class T> void destroy(T* p);

-    template <class T> void destroy(T* p) noexcept;
-
-    scoped_allocator_adaptor select_on_container_copy_construction() const noexcept;
+    scoped_allocator_adaptor select_on_container_copy_construction() const;
 };

 template <class OuterA1, class OuterA2, class... InnerAllocs>
    bool
    operator==(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
-               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
+               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);

 template <class OuterA1, class OuterA2, class... InnerAllocs>
    bool
    operator!=(const scoped_allocator_adaptor<OuterA1, InnerAllocs...>& a,
-               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b) noexcept;
+               const scoped_allocator_adaptor<OuterA2, InnerAllocs...>& b);

 }  // std

@@ -185,7 +182,7 @@ private:
 protected:

    _LIBCPP_INLINE_VISIBILITY
-    __scoped_allocator_storage() _NOEXCEPT {}
+    __scoped_allocator_storage() {}

    template <class _OuterA2,
              class = typename enable_if<
@@ -193,8 +190,8 @@ protected:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        __scoped_allocator_storage(_OuterA2&& __outerAlloc,
-                                   const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)),
+                                   const _InnerAllocs& ...__innerAllocs)
+            : outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)),
              __inner_(__innerAllocs...) {}

    template <class _OuterA2,
@@ -203,7 +200,7 @@ protected:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        __scoped_allocator_storage(
-            const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
+            const __scoped_allocator_storage<_OuterA2, _InnerAllocs...>& __other)
            : outer_allocator_type(__other.outer_allocator()),
              __inner_(__other.inner_allocator()) {}

@@ -213,9 +210,9 @@ protected:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        __scoped_allocator_storage(
-            __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-            : outer_allocator_type(_VSTD::move(__other.outer_allocator())),
-              __inner_(_VSTD::move(__other.inner_allocator())) {}
+            __scoped_allocator_storage<_OuterA2, _InnerAllocs...>&& __other)
+            : outer_allocator_type(_STD::move(__other.outer_allocator())),
+              __inner_(_STD::move(__other.inner_allocator())) {}

    template <class _OuterA2,
              class = typename enable_if<
@@ -223,27 +220,27 @@ protected:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        __scoped_allocator_storage(_OuterA2&& __o,
-                                   const inner_allocator_type& __i) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__o)),
+                                   const inner_allocator_type& __i)
+            : outer_allocator_type(_STD::forward<_OuterA2>(__o)),
              __inner_(__i)
        {
        }

    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT             {return __inner_;}
+    inner_allocator_type& inner_allocator()             {return __inner_;}
    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT {return __inner_;}
+    const inner_allocator_type& inner_allocator() const {return __inner_;}

    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
+    outer_allocator_type& outer_allocator()
        {return static_cast<outer_allocator_type&>(*this);}
    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
+    const outer_allocator_type& outer_allocator() const
        {return static_cast<const outer_allocator_type&>(*this);}

    scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
    _LIBCPP_INLINE_VISIBILITY
-    select_on_container_copy_construction() const _NOEXCEPT
+    select_on_container_copy_construction() const
        {
            return scoped_allocator_adaptor<outer_allocator_type, _InnerAllocs...>
            (
@@ -266,15 +263,15 @@ protected:
    typedef scoped_allocator_adaptor<_OuterAlloc> inner_allocator_type;

    _LIBCPP_INLINE_VISIBILITY
-    __scoped_allocator_storage() _NOEXCEPT {}
+    __scoped_allocator_storage() {}

    template <class _OuterA2,
              class = typename enable_if<
                        is_constructible<outer_allocator_type, _OuterA2>::value
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
-        __scoped_allocator_storage(_OuterA2&& __outerAlloc) _NOEXCEPT
-            : outer_allocator_type(_VSTD::forward<_OuterA2>(__outerAlloc)) {}
+        __scoped_allocator_storage(_OuterA2&& __outerAlloc)
+            : outer_allocator_type(_STD::forward<_OuterA2>(__outerAlloc)) {}

    template <class _OuterA2,
              class = typename enable_if<
@@ -282,7 +279,7 @@ protected:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        __scoped_allocator_storage(
-            const __scoped_allocator_storage<_OuterA2>& __other) _NOEXCEPT
+            const __scoped_allocator_storage<_OuterA2>& __other)
            : outer_allocator_type(__other.outer_allocator()) {}

    template <class _OuterA2,
@@ -291,33 +288,33 @@ protected:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        __scoped_allocator_storage(
-            __scoped_allocator_storage<_OuterA2>&& __other) _NOEXCEPT
-            : outer_allocator_type(_VSTD::move(__other.outer_allocator())) {}
+            __scoped_allocator_storage<_OuterA2>&& __other)
+            : outer_allocator_type(_STD::move(__other.outer_allocator())) {}

    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT
+    inner_allocator_type& inner_allocator()
        {return static_cast<inner_allocator_type&>(*this);}
    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT
+    const inner_allocator_type& inner_allocator() const
        {return static_cast<const inner_allocator_type&>(*this);}

    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
+    outer_allocator_type& outer_allocator()
        {return static_cast<outer_allocator_type&>(*this);}
    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
+    const outer_allocator_type& outer_allocator() const
        {return static_cast<const outer_allocator_type&>(*this);}

    _LIBCPP_INLINE_VISIBILITY
    scoped_allocator_adaptor<outer_allocator_type>
-    select_on_container_copy_construction() const _NOEXCEPT
+    select_on_container_copy_construction() const
        {return scoped_allocator_adaptor<outer_allocator_type>(
            allocator_traits<outer_allocator_type>::
                select_on_container_copy_construction(outer_allocator())
        );}

    __scoped_allocator_storage(const outer_allocator_type& __o,
-                               const inner_allocator_type& __i) _NOEXCEPT;
+                               const inner_allocator_type& __i);

    template <class...> friend class __scoped_allocator_storage;
 };
@@ -346,7 +343,7 @@ struct __outermost
 {
    typedef _Alloc type;
    _LIBCPP_INLINE_VISIBILITY
-    type& operator()(type& __a) const _NOEXCEPT {return __a;}
+    type& operator()(type& __a) const {return __a;}
 };

 template <class _Alloc>
@@ -354,11 +351,11 @@ struct __outermost<_Alloc, true>
 {
    typedef typename remove_reference
                     <
-                        decltype(_VSTD::declval<_Alloc>().outer_allocator())
+                        decltype(_STD::declval<_Alloc>().outer_allocator())
                     >::type                                    _OuterAlloc;
    typedef typename __outermost<_OuterAlloc>::type             type;
    _LIBCPP_INLINE_VISIBILITY
-    type& operator()(_Alloc& __a) const _NOEXCEPT
+    type& operator()(_Alloc& __a) const
        {return __outermost<_OuterAlloc>()(__a.outer_allocator());}
 };

@@ -406,15 +403,15 @@ public:
    };

    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor() _NOEXCEPT {}
+    scoped_allocator_adaptor() {}
    template <class _OuterA2,
              class = typename enable_if<
                        is_constructible<outer_allocator_type, _OuterA2>::value
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        scoped_allocator_adaptor(_OuterA2&& __outerAlloc,
-                                 const _InnerAllocs& ...__innerAllocs) _NOEXCEPT
-            : base(_VSTD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
+                                 const _InnerAllocs& ...__innerAllocs)
+            : base(_STD::forward<_OuterA2>(__outerAlloc), __innerAllocs...) {}
    // scoped_allocator_adaptor(const scoped_allocator_adaptor& __other) = default;
    template <class _OuterA2,
              class = typename enable_if<
@@ -422,7 +419,7 @@ public:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        scoped_allocator_adaptor(
-            const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other) _NOEXCEPT
+            const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __other)
                : base(__other) {}
    template <class _OuterA2,
              class = typename enable_if<
@@ -430,23 +427,23 @@ public:
                      >::type>
        _LIBCPP_INLINE_VISIBILITY
        scoped_allocator_adaptor(
-            scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other) _NOEXCEPT
-                : base(_VSTD::move(__other)) {}
+            scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>&& __other)
+                : base(_STD::move(__other)) {}

    // ~scoped_allocator_adaptor() = default;

    _LIBCPP_INLINE_VISIBILITY
-    inner_allocator_type& inner_allocator() _NOEXCEPT
+    inner_allocator_type& inner_allocator()
        {return base::inner_allocator();}
    _LIBCPP_INLINE_VISIBILITY
-    const inner_allocator_type& inner_allocator() const _NOEXCEPT
+    const inner_allocator_type& inner_allocator() const
        {return base::inner_allocator();}

    _LIBCPP_INLINE_VISIBILITY
-    outer_allocator_type& outer_allocator() _NOEXCEPT
+    outer_allocator_type& outer_allocator()
        {return base::outer_allocator();}
    _LIBCPP_INLINE_VISIBILITY
-    const outer_allocator_type& outer_allocator() const _NOEXCEPT
+    const outer_allocator_type& outer_allocator() const
        {return base::outer_allocator();}

    _LIBCPP_INLINE_VISIBILITY
@@ -459,7 +456,7 @@ public:
            allocate(outer_allocator(), __n, __hint);}

    _LIBCPP_INLINE_VISIBILITY
-    void deallocate(pointer __p, size_type __n) _NOEXCEPT
+    void deallocate(pointer __p, size_type __n)
        {allocator_traits<outer_allocator_type>::
            deallocate(outer_allocator(), __p, __n);}

@@ -471,7 +468,7 @@ public:
        _LIBCPP_INLINE_VISIBILITY
        void construct(_Tp* __p, _Args&& ...__args)
            {__construct(__uses_alloc_ctor<_Tp, inner_allocator_type, _Args...>(),
-                         __p, _VSTD::forward<_Args>(__args)...);}
+                         __p, _STD::forward<_Args>(__args)...);}
    template <class _Tp>
        _LIBCPP_INLINE_VISIBILITY
        void destroy(_Tp* __p)
@@ -482,7 +479,7 @@ public:
            }

    _LIBCPP_INLINE_VISIBILITY
-    scoped_allocator_adaptor select_on_container_copy_construction() const _NOEXCEPT
+    scoped_allocator_adaptor select_on_container_copy_construction() const
        {return base::select_on_container_copy_construction();}

 private:
@@ -493,8 +490,8 @@ private:
                      >::type>
    _LIBCPP_INLINE_VISIBILITY
    scoped_allocator_adaptor(_OuterA2&& __o,
-                             const inner_allocator_type& __i) _NOEXCEPT
-        : base(_VSTD::forward<_OuterA2>(__o), __i) {}
+                             const inner_allocator_type& __i)
+        : base(_STD::forward<_OuterA2>(__o), __i) {}

    template <class _Tp, class... _Args>
        _LIBCPP_INLINE_VISIBILITY
@@ -505,7 +502,7 @@ private:
                (
                    _OM()(outer_allocator()),
                    __p,
-                    _VSTD::forward<_Args>(__args)...
+                    _STD::forward<_Args>(__args)...
                );
            }

@@ -520,7 +517,7 @@ private:
                    __p,
                    allocator_arg,
                    inner_allocator(),
-                    _VSTD::forward<_Args>(__args)...
+                    _STD::forward<_Args>(__args)...
                );
            }

@@ -533,7 +530,7 @@ private:
                (
                    _OM()(outer_allocator()),
                    __p,
-                    _VSTD::forward<_Args>(__args)...,
+                    _STD::forward<_Args>(__args)...,
                    inner_allocator()
                );
            }
@@ -545,7 +542,7 @@ template <class _OuterA1, class _OuterA2>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const scoped_allocator_adaptor<_OuterA1>& __a,
-           const scoped_allocator_adaptor<_OuterA2>& __b) _NOEXCEPT
+           const scoped_allocator_adaptor<_OuterA2>& __b)
 {
    return __a.outer_allocator() == __b.outer_allocator();
 }
@@ -554,7 +551,7 @@ template <class _OuterA1, class _OuterA2, class _InnerA0, class... _InnerAllocs>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator==(const scoped_allocator_adaptor<_OuterA1, _InnerA0, _InnerAllocs...>& __a,
-           const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b) _NOEXCEPT
+           const scoped_allocator_adaptor<_OuterA2, _InnerA0, _InnerAllocs...>& __b)
 {
    return __a.outer_allocator() == __b.outer_allocator() &&
           __a.inner_allocator() == __b.inner_allocator();
@@ -564,7 +561,7 @@ template <class _OuterA1, class _OuterA2, class... _InnerAllocs>
 inline _LIBCPP_INLINE_VISIBILITY
 bool
 operator!=(const scoped_allocator_adaptor<_OuterA1, _InnerAllocs...>& __a,
-           const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b) _NOEXCEPT
+           const scoped_allocator_adaptor<_OuterA2, _InnerAllocs...>& __b)
 {
    return !(__a == __b);
 }
--- a/include/set
+++ b/include/set
@@ -42,12 +42,7 @@ public:
    typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;

    // construct/copy/destroy:
-    set()
-        noexcept(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value);
-    explicit set(const value_compare& comp);
+    explicit set(const value_compare& comp = value_compare());
    set(const value_compare& comp, const allocator_type& a);
    template <class InputIterator>
        set(InputIterator first, InputIterator last,
@@ -56,10 +51,7 @@ public:
        set(InputIterator first, InputIterator last, const value_compare& comp,
            const allocator_type& a);
    set(const set& s);
-    set(set&& s)
-        noexcept(
-            is_nothrow_move_constructible<allocator_type>::value &&
-            is_nothrow_move_constructible<key_compare>::value);
+    set(set&& s);
    explicit set(const allocator_type& a);
    set(const set& s, const allocator_type& a);
    set(set&& s, const allocator_type& a);
@@ -69,33 +61,29 @@ public:
    ~set();

    set& operator=(const set& s);
-    set& operator=(set&& s)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<key_compare>::value);
+    set& operator=(set&& s);
    set& operator=(initializer_list<value_type> il);

    // iterators:
-          iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-          iterator end() noexcept;
-    const_iterator end()   const noexcept;
+          iterator begin();
+    const_iterator begin() const;
+          iterator end();
+    const_iterator end()   const;

-          reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-          reverse_iterator rend() noexcept;
-    const_reverse_iterator rend()   const noexcept;
+          reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+          reverse_iterator rend();
+    const_reverse_iterator rend()   const;

-    const_iterator         cbegin()  const noexcept;
-    const_iterator         cend()    const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend()   const noexcept;
+    const_iterator         cbegin()  const;
+    const_iterator         cend()    const;
+    const_reverse_iterator crbegin() const;
+    const_reverse_iterator crend()   const;

    // capacity:
-    bool      empty()    const noexcept;
-    size_type size()     const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty()    const;
+    size_type size()     const;
+    size_type max_size() const;

    // modifiers:
    template <class... Args>
@@ -113,16 +101,12 @@ public:
    iterator  erase(const_iterator position);
    size_type erase(const key_type& k);
    iterator  erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();

-    void swap(set& s)
-        noexcept(
-            __is_nothrow_swappable<key_compare>::value &&
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value));
+    void swap(set& s);

    // observers:
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;
    key_compare    key_comp()      const;
    value_compare  value_comp()    const;

@@ -171,8 +155,7 @@ operator<=(const set<Key, Compare, Allocator>& x,
 // specialized algorithms:
 template <class Key, class Compare, class Allocator>
 void
-swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y)
-    noexcept(noexcept(x.swap(y)));
+swap(set<Key, Compare, Allocator>& x, set<Key, Compare, Allocator>& y);

 template <class Key, class Compare = less<Key>,
          class Allocator = allocator<Key>>
@@ -198,12 +181,7 @@ public:
    typedef std::reverse_iterator<const_iterator>    const_reverse_iterator;

    // construct/copy/destroy:
-    multiset()
-        noexcept(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value);
-    explicit multiset(const value_compare& comp);
+    explicit multiset(const value_compare& comp = value_compare());
    multiset(const value_compare& comp, const allocator_type& a);
    template <class InputIterator>
        multiset(InputIterator first, InputIterator last,
@@ -212,10 +190,7 @@ public:
        multiset(InputIterator first, InputIterator last,
                 const value_compare& comp, const allocator_type& a);
    multiset(const multiset& s);
-    multiset(multiset&& s)
-        noexcept(
-            is_nothrow_move_constructible<allocator_type>::value &&
-            is_nothrow_move_constructible<key_compare>::value);
+    multiset(multiset&& s);
    explicit multiset(const allocator_type& a);
    multiset(const multiset& s, const allocator_type& a);
    multiset(multiset&& s, const allocator_type& a);
@@ -225,33 +200,29 @@ public:
    ~multiset();

    multiset& operator=(const multiset& s);
-    multiset& operator=(multiset&& s)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<key_compare>::value);
+    multiset& operator=(multiset&& s);
    multiset& operator=(initializer_list<value_type> il);

    // iterators:
-          iterator begin() noexcept;
-    const_iterator begin() const noexcept;
-          iterator end() noexcept;
-    const_iterator end()   const noexcept;
+          iterator begin();
+    const_iterator begin() const;
+          iterator end();
+    const_iterator end()   const;

-          reverse_iterator rbegin() noexcept;
-    const_reverse_iterator rbegin() const noexcept;
-          reverse_iterator rend() noexcept;
-    const_reverse_iterator rend()   const noexcept;
+          reverse_iterator rbegin();
+    const_reverse_iterator rbegin() const;
+          reverse_iterator rend();
+    const_reverse_iterator rend()   const;

-    const_iterator         cbegin()  const noexcept;
-    const_iterator         cend()    const noexcept;
-    const_reverse_iterator crbegin() const noexcept;
-    const_reverse_iterator crend()   const noexcept;
+    const_iterator         cbegin()  const;
+    const_iterator         cend()    const;
+    const_reverse_iterator crbegin() const;
+    const_reverse_iterator crend()   const;

    // capacity:
-    bool      empty()    const noexcept;
-    size_type size()     const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty()    const;
+    size_type size()     const;
+    size_type max_size() const;

    // modifiers:
    template <class... Args>
@@ -269,16 +240,12 @@ public:
    iterator  erase(const_iterator position);
    size_type erase(const key_type& k);
    iterator  erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();

-    void swap(multiset& s)
-        noexcept(
-            __is_nothrow_swappable<key_compare>::value &&
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value));
+    void swap(multiset& s);

    // observers:
-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;
    key_compare    key_comp()      const;
    value_compare  value_comp()    const;

@@ -327,8 +294,7 @@ operator<=(const multiset<Key, Compare, Allocator>& x,
 // specialized algorithms:
 template <class Key, class Compare, class Allocator>
 void
-swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y)
-    noexcept(noexcept(x.swap(y)));
+swap(multiset<Key, Compare, Allocator>& x, multiset<Key, Compare, Allocator>& y);

 }  // std

@@ -370,15 +336,11 @@ public:
    typedef typename __base::difference_type       difference_type;
    typedef typename __base::const_iterator        iterator;
    typedef typename __base::const_iterator        const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef _STD::reverse_iterator<iterator>       reverse_iterator;
+    typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;

    _LIBCPP_INLINE_VISIBILITY
    explicit set(const value_compare& __comp = value_compare())
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
        : __tree_(__comp) {}
    _LIBCPP_INLINE_VISIBILITY
    set(const value_compare& __comp, const allocator_type& __a)
@@ -408,18 +370,10 @@ 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_(_VSTD::move(__s.__tree_)) {}
+        : __tree_(_STD::move(__s.__tree_)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
@@ -437,7 +391,6 @@ public:
    set(set&& __s, const allocator_type& __a);
 #endif

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    set(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
        : __tree_(__comp)
@@ -459,66 +412,60 @@ public:
            __tree_.__assign_unique(__il.begin(), __il.end());
            return *this;
        }
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    set& operator=(set&& __s)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
        {
-            __tree_ = _VSTD::move(__s.__tree_);
+            __tree_ = _STD::move(__s.__tree_);
            return *this;
        }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT       {return __tree_.begin();}
+          iterator begin()       {return __tree_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
+    const_iterator begin() const {return __tree_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT         {return __tree_.end();}
+          iterator end()         {return __tree_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __tree_.end();}
+    const_iterator end()   const {return __tree_.end();}

    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return reverse_iterator(end());}
+          reverse_iterator rbegin()       {return       reverse_iterator(end());}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
+    const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return reverse_iterator(begin());}
+          reverse_iterator rend()         {return       reverse_iterator(begin());}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+    const_reverse_iterator rend()   const {return const_reverse_iterator(begin());}

    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
+    const_iterator         cbegin()  const {return begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
+    const_iterator         cend()    const {return end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
+    const_reverse_iterator crbegin() const {return rbegin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+    const_reverse_iterator crend()   const {return rend();}

    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
+    bool      empty()    const {return __tree_.size() == 0;}
    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
+    size_type size()     const {return __tree_.size();}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
+    size_type max_size() const {return __tree_.max_size();}

    // modifiers:
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        pair<iterator, bool> emplace(_Args&&... __args)
-            {return __tree_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_unique(_STD::forward<_Args>(__args)...);}
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __tree_.__emplace_hint_unique(__p, _VSTD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_hint_unique(__p, _STD::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)
@@ -526,7 +473,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    pair<iterator,bool> insert(value_type&& __v)
-        {return __tree_.__insert_unique(_VSTD::move(__v));}
+        {return __tree_.__insert_unique(_STD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator __p, const value_type& __v)
@@ -534,7 +481,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_unique(__p, _VSTD::move(__v));}
+        {return __tree_.__insert_unique(__p, _STD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _InputIterator>
        _LIBCPP_INLINE_VISIBILITY
@@ -544,11 +491,9 @@ public:
                __tree_.__insert_unique(__e, *__f);
        }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    void insert(initializer_list<value_type> __il)
        {insert(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
    iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
@@ -559,14 +504,13 @@ public:
    iterator  erase(const_iterator __f, const_iterator __l)
        {return __tree_.erase(__f, __l);}
    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+    void clear() {__tree_.clear();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(set& __s) _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__s.__tree_);}
+    void swap(set& __s) {__tree_.swap(__s.__tree_);}

    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
+    allocator_type get_allocator() const {return __tree_.__alloc();}
    _LIBCPP_INLINE_VISIBILITY
    key_compare    key_comp()      const {return __tree_.value_comp();}
    _LIBCPP_INLINE_VISIBILITY
@@ -604,13 +548,13 @@ public:

 template <class _Key, class _Compare, class _Allocator>
 set<_Key, _Compare, _Allocator>::set(set&& __s, const allocator_type& __a)
-    : __tree_(_VSTD::move(__s.__tree_), __a)
+    : __tree_(_STD::move(__s.__tree_), __a)
 {
    if (__a != __s.get_allocator())
    {
        const_iterator __e = cend();
        while (!__s.empty())
-            insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
+            insert(__e, _STD::move(__s.__tree_.remove(__s.begin())->__value_));
    }
 }

@@ -622,7 +566,7 @@ bool
 operator==(const set<_Key, _Compare, _Allocator>& __x,
           const set<_Key, _Compare, _Allocator>& __y)
 {
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
 }

 template <class _Key, class _Compare, class _Allocator>
@@ -631,7 +575,7 @@ bool
 operator< (const set<_Key, _Compare, _Allocator>& __x,
           const set<_Key, _Compare, _Allocator>& __y)
 {
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }

 template <class _Key, class _Compare, class _Allocator>
@@ -676,7 +620,6 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(set<_Key, _Compare, _Allocator>& __x,
     set<_Key, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
@@ -709,16 +652,12 @@ public:
    typedef typename __base::difference_type       difference_type;
    typedef typename __base::const_iterator        iterator;
    typedef typename __base::const_iterator        const_iterator;
-    typedef _VSTD::reverse_iterator<iterator>       reverse_iterator;
-    typedef _VSTD::reverse_iterator<const_iterator> const_reverse_iterator;
+    typedef _STD::reverse_iterator<iterator>       reverse_iterator;
+    typedef _STD::reverse_iterator<const_iterator> const_reverse_iterator;

    // construct/copy/destroy:
    _LIBCPP_INLINE_VISIBILITY
    explicit multiset(const value_compare& __comp = value_compare())
-        _NOEXCEPT_(
-            is_nothrow_default_constructible<allocator_type>::value &&
-            is_nothrow_default_constructible<key_compare>::value &&
-            is_nothrow_copy_constructible<key_compare>::value)
        : __tree_(__comp) {}
    _LIBCPP_INLINE_VISIBILITY
    multiset(const value_compare& __comp, const allocator_type& __a)
@@ -749,18 +688,10 @@ 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_(_VSTD::move(__s.__tree_)) {}
+        : __tree_(_STD::move(__s.__tree_)) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    explicit multiset(const allocator_type& __a)
@@ -775,7 +706,6 @@ public:
    multiset(multiset&& __s, const allocator_type& __a);
 #endif

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    multiset(initializer_list<value_type> __il, const value_compare& __comp = value_compare())
        : __tree_(__comp)
@@ -797,66 +727,60 @@ public:
            __tree_.__assign_multi(__il.begin(), __il.end());
            return *this;
        }
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    multiset& operator=(multiset&& __s)
-        _NOEXCEPT_(is_nothrow_move_assignable<__base>::value)
        {
-            __tree_ = _VSTD::move(__s.__tree_);
+            __tree_ = _STD::move(__s.__tree_);
            return *this;
        }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
-          iterator begin() _NOEXCEPT       {return __tree_.begin();}
+          iterator begin()       {return __tree_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin() const _NOEXCEPT {return __tree_.begin();}
+    const_iterator begin() const {return __tree_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-          iterator end() _NOEXCEPT         {return __tree_.end();}
+          iterator end()         {return __tree_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()   const _NOEXCEPT {return __tree_.end();}
+    const_iterator end()   const {return __tree_.end();}

    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rbegin() _NOEXCEPT
-            {return reverse_iterator(end());}
+          reverse_iterator rbegin()       {return       reverse_iterator(end());}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rbegin() const _NOEXCEPT
-        {return const_reverse_iterator(end());}
+    const_reverse_iterator rbegin() const {return const_reverse_iterator(end());}
    _LIBCPP_INLINE_VISIBILITY
-          reverse_iterator rend() _NOEXCEPT
-            {return       reverse_iterator(begin());}
+          reverse_iterator rend()         {return       reverse_iterator(begin());}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator rend() const _NOEXCEPT
-        {return const_reverse_iterator(begin());}
+    const_reverse_iterator rend()   const {return const_reverse_iterator(begin());}

    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin()  const _NOEXCEPT {return begin();}
+    const_iterator         cbegin()  const {return begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend() const _NOEXCEPT {return end();}
+    const_iterator         cend()    const {return end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crbegin() const _NOEXCEPT {return rbegin();}
+    const_reverse_iterator crbegin() const {return rbegin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_reverse_iterator crend() const _NOEXCEPT {return rend();}
+    const_reverse_iterator crend()   const {return rend();}

    _LIBCPP_INLINE_VISIBILITY
-    bool empty() const _NOEXCEPT {return __tree_.size() == 0;}
+    bool      empty()    const {return __tree_.size() == 0;}
    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT {return __tree_.size();}
+    size_type size()     const {return __tree_.size();}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __tree_.max_size();}
+    size_type max_size() const {return __tree_.max_size();}

    // modifiers:
 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        iterator emplace(_Args&&... __args)
-            {return __tree_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_multi(_STD::forward<_Args>(__args)...);}
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __tree_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
+            {return __tree_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);}
 #endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const value_type& __v)
@@ -864,7 +788,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(value_type&& __v)
-        {return __tree_.__insert_multi(_VSTD::move(__v));}
+        {return __tree_.__insert_multi(_STD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator __p, const value_type& __v)
@@ -872,7 +796,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator __p, value_type&& __v)
-        {return __tree_.__insert_multi(_VSTD::move(__v));}
+        {return __tree_.__insert_multi(_STD::move(__v));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _InputIterator>
        _LIBCPP_INLINE_VISIBILITY
@@ -882,11 +806,9 @@ public:
                __tree_.__insert_multi(__e, *__f);
        }

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    void insert(initializer_list<value_type> __il)
        {insert(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
    iterator  erase(const_iterator __p) {return __tree_.erase(__p);}
@@ -896,15 +818,13 @@ public:
    iterator  erase(const_iterator __f, const_iterator __l)
        {return __tree_.erase(__f, __l);}
    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__tree_.clear();}
+    void clear() {__tree_.clear();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(multiset& __s)
-        _NOEXCEPT_(__is_nothrow_swappable<__base>::value)
-        {__tree_.swap(__s.__tree_);}
+    void swap(multiset& __s) {__tree_.swap(__s.__tree_);}

    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT {return __tree_.__alloc();}
+    allocator_type get_allocator() const {return __tree_.__alloc();}
    _LIBCPP_INLINE_VISIBILITY
    key_compare    key_comp()      const {return __tree_.value_comp();}
    _LIBCPP_INLINE_VISIBILITY
@@ -942,13 +862,13 @@ public:

 template <class _Key, class _Compare, class _Allocator>
 multiset<_Key, _Compare, _Allocator>::multiset(multiset&& __s, const allocator_type& __a)
-    : __tree_(_VSTD::move(__s.__tree_), __a)
+    : __tree_(_STD::move(__s.__tree_), __a)
 {
    if (__a != __s.get_allocator())
    {
        const_iterator __e = cend();
        while (!__s.empty())
-            insert(__e, _VSTD::move(__s.__tree_.remove(__s.begin())->__value_));
+            insert(__e, _STD::move(__s.__tree_.remove(__s.begin())->__value_));
    }
 }

@@ -960,7 +880,7 @@ bool
 operator==(const multiset<_Key, _Compare, _Allocator>& __x,
           const multiset<_Key, _Compare, _Allocator>& __y)
 {
-    return __x.size() == __y.size() && _VSTD::equal(__x.begin(), __x.end(), __y.begin());
+    return __x.size() == __y.size() && _STD::equal(__x.begin(), __x.end(), __y.begin());
 }

 template <class _Key, class _Compare, class _Allocator>
@@ -969,7 +889,7 @@ bool
 operator< (const multiset<_Key, _Compare, _Allocator>& __x,
           const multiset<_Key, _Compare, _Allocator>& __y)
 {
-    return _VSTD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
+    return _STD::lexicographical_compare(__x.begin(), __x.end(), __y.begin(), __y.end());
 }

 template <class _Key, class _Compare, class _Allocator>
@@ -1013,7 +933,6 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(multiset<_Key, _Compare, _Allocator>& __x,
     multiset<_Key, _Compare, _Allocator>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
--- a/include/sstream
+++ b/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_ = _VSTD::move(__rhs.__str_);
+    __str_ = _STD::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_ = _VSTD::move(__rhs.__str_);
+    __str_ = _STD::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();
-    _VSTD::swap(__mode_, __rhs.__mode_);
+    _STD::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_ = _VSTD::max(this->pptr() + 1, __hm_);
+        __hm_ = _STD::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>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
+    : basic_istream<_CharT, _Traits>(_STD::move(__rhs)),
+      __sb_(_STD::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=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
+    basic_istream<char_type, traits_type>::operator=(_STD::move(__rhs));
+    __sb_ = _STD::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>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
+    : basic_ostream<_CharT, _Traits>(_STD::move(__rhs)),
+      __sb_(_STD::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=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
+    basic_ostream<char_type, traits_type>::operator=(_STD::move(__rhs));
+    __sb_ = _STD::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>(_VSTD::move(__rhs)),
-      __sb_(_VSTD::move(__rhs.__sb_))
+    : basic_iostream<_CharT, _Traits>(_STD::move(__rhs)),
+      __sb_(_STD::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=(_VSTD::move(__rhs));
-    __sb_ = _VSTD::move(__rhs.__sb_);
+    basic_iostream<char_type, traits_type>::operator=(_STD::move(__rhs));
+    __sb_ = _STD::move(__rhs.__sb_);
    return *this;
 }

--- a/include/stack
+++ b/include/stack
@@ -31,21 +31,14 @@ protected:
    container_type c;

 public:
-    stack() = default;
-    ~stack() = default;
-
-    stack(const stack& q) = default;
-    stack(stack&& q) = default;
-
-    stack& operator=(const stack& q) = default;
-    stack& operator=(stack&& q) = default;
-
+    explicit stack();
    explicit stack(const container_type& c);
    explicit stack(container_type&& c);
+    stack(stack&& s);
+    stack& operator=(stack&& s);
    template <class Alloc> explicit stack(const Alloc& a);
    template <class Alloc> stack(const container_type& c, const Alloc& a);
    template <class Alloc> stack(container_type&& c, const Alloc& a);
-    template <class Alloc> stack(const stack& c, const Alloc& a);
    template <class Alloc> stack(stack&& c, const Alloc& a);

    bool empty() const;
@@ -58,7 +51,7 @@ public:
    template <class... Args> void emplace(Args&&... args);
    void pop();

-    void swap(stack& c) noexcept(noexcept(swap(c, q.c)));
+    void swap(stack& c);
 };

 template <class T, class Container>
@@ -75,8 +68,7 @@ template <class T, class Container>
  bool operator<=(const stack<T, Container>& x, const stack<T, Container>& y);

 template <class T, class Container>
-  void swap(stack<T, Container>& x, stack<T, Container>& y)
-  noexcept(noexcept(x.swap(y)));
+  void swap(stack<T, Container>& x, stack<T, Container>& y);

 }  // std

@@ -114,35 +106,16 @@ protected:

 public:
    _LIBCPP_INLINE_VISIBILITY
-    stack()
-        _NOEXCEPT_(is_nothrow_default_constructible<container_type>::value)
-        : c() {}
-
-    _LIBCPP_INLINE_VISIBILITY
-    stack(const stack& __q) : c(__q.c) {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    stack(stack&& __q)
-        _NOEXCEPT_(is_nothrow_move_constructible<container_type>::value)
-        : c(_VSTD::move(__q.c)) {}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    _LIBCPP_INLINE_VISIBILITY
-    stack& operator=(const stack& __q) {c = __q.c; return *this;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    stack& operator=(stack&& __q)
-        _NOEXCEPT_(is_nothrow_move_assignable<container_type>::value)
-        {c = _VSTD::move(__q.c); return *this;}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
+    stack() : c() {}
    _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(_VSTD::move(__c)) {}
+    explicit stack(container_type&& __c) : c(_STD::move(__c)) {}
+    _LIBCPP_INLINE_VISIBILITY
+    stack(stack&& __s) : c(_STD::move(__s.c)) {}
+    _LIBCPP_INLINE_VISIBILITY
+    stack& operator=(stack&& __s) {c = _STD::move(__s.c); return *this;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _Alloc>
        _LIBCPP_INLINE_VISIBILITY
@@ -168,13 +141,13 @@ public:
        stack(container_type&& __c, const _Alloc& __a,
              typename enable_if<uses_allocator<container_type,
                                                _Alloc>::value>::type* = 0)
-            : c(_VSTD::move(__c), __a) {}
+            : c(_STD::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(_VSTD::move(__s.c), __a) {}
+            : c(_STD::move(__s.c), __a) {}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
@@ -190,12 +163,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(_VSTD::move(__v));}
+    void push(value_type&& __v) {c.push_back(_STD::move(__v));}
 #ifndef _LIBCPP_HAS_NO_VARIADICS
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        void emplace(_Args&&... __args)
-        {c.emplace_back(_VSTD::forward<_Args>(__args)...);}
+        {c.emplace_back(_STD::forward<_Args>(__args)...);}
 #endif  // _LIBCPP_HAS_NO_VARIADICS
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
@@ -203,9 +176,8 @@ public:

    _LIBCPP_INLINE_VISIBILITY
    void swap(stack& __s)
-        _NOEXCEPT_(__is_nothrow_swappable<container_type>::value)
    {
-        using _VSTD::swap;
+        using _STD::swap;
        swap(c, __s.c);
    }

@@ -272,7 +244,6 @@ template <class _Tp, class _Container>
 inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(stack<_Tp, _Container>& __x, stack<_Tp, _Container>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
--- a/include/stdexcept
+++ b/include/stdexcept
@@ -33,9 +33,9 @@ class xxx_error : public exception // at least indirectly
 {
 public:
    explicit xxx_error(const string& what_arg);
-    explicit xxx_error(const char*   what_arg);
+    explicit xxx_error(const char*   what_arg);  // extension

-    virtual const char* what() const noexcept // returns what_arg
+    virtual const char* what() const // returns what_arg
 };

 }  // std
@@ -60,12 +60,12 @@ public:
    explicit logic_error(const string&);
    explicit logic_error(const char*);

-    logic_error(const logic_error&) _NOEXCEPT;
-    logic_error& operator=(const logic_error&) _NOEXCEPT;
+    logic_error(const logic_error&) throw();
+    logic_error& operator=(const logic_error&) throw();

-    virtual ~logic_error() _NOEXCEPT;
+    virtual ~logic_error() throw();

-    virtual const char* what() const _NOEXCEPT;
+    virtual const char* what() const throw();
 };

 class _LIBCPP_EXCEPTION_ABI runtime_error
@@ -77,12 +77,12 @@ public:
    explicit runtime_error(const string&);
    explicit runtime_error(const char*);

-    runtime_error(const runtime_error&) _NOEXCEPT;
-    runtime_error& operator=(const runtime_error&) _NOEXCEPT;
+    runtime_error(const runtime_error&) throw();
+    runtime_error& operator=(const runtime_error&) throw();

-    virtual ~runtime_error() _NOEXCEPT;
+    virtual ~runtime_error() throw();

-    virtual const char* what() const _NOEXCEPT;
+    virtual const char* what() const throw();
 };

 class _LIBCPP_EXCEPTION_ABI domain_error
@@ -92,7 +92,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit domain_error(const string& __s) : logic_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit domain_error(const char* __s)   : logic_error(__s) {}

-    virtual ~domain_error() _NOEXCEPT;
+    virtual ~domain_error() throw();
 };

 class _LIBCPP_EXCEPTION_ABI invalid_argument
@@ -102,7 +102,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const string& __s) : logic_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit invalid_argument(const char* __s)   : logic_error(__s) {}

-    virtual ~invalid_argument() _NOEXCEPT;
+    virtual ~invalid_argument() throw();
 };

 class _LIBCPP_EXCEPTION_ABI length_error
@@ -112,7 +112,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit length_error(const string& __s) : logic_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit length_error(const char* __s)   : logic_error(__s) {}

-    virtual ~length_error() _NOEXCEPT;
+    virtual ~length_error() throw();
 };

 class _LIBCPP_EXCEPTION_ABI out_of_range
@@ -122,7 +122,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const string& __s) : logic_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit out_of_range(const char* __s)   : logic_error(__s) {}

-    virtual ~out_of_range() _NOEXCEPT;
+    virtual ~out_of_range() throw();
 };

 class _LIBCPP_EXCEPTION_ABI range_error
@@ -132,7 +132,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit range_error(const string& __s) : runtime_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit range_error(const char* __s)   : runtime_error(__s) {}

-    virtual ~range_error() _NOEXCEPT;
+    virtual ~range_error() throw();
 };

 class _LIBCPP_EXCEPTION_ABI overflow_error
@@ -142,7 +142,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const string& __s) : runtime_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit overflow_error(const char* __s)   : runtime_error(__s) {}

-    virtual ~overflow_error() _NOEXCEPT;
+    virtual ~overflow_error() throw();
 };

 class _LIBCPP_EXCEPTION_ABI underflow_error
@@ -152,7 +152,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const string& __s) : runtime_error(__s) {}
    _LIBCPP_INLINE_VISIBILITY explicit underflow_error(const char* __s)   : runtime_error(__s) {}

-    virtual ~underflow_error() _NOEXCEPT;
+    virtual ~underflow_error() throw();
 };

 }  // std
--- a/include/streambuf
+++ b/include/streambuf
@@ -399,13 +399,13 @@ template <class _CharT, class _Traits>
 void
 basic_streambuf<_CharT, _Traits>::swap(basic_streambuf& __sb)
 {
-    _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_);
+    _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_);
 }

 template <class _CharT, class _Traits>
--- a/include/string
+++ b/include/string
--- a/include/strstream
+++ b/include/strstream
@@ -150,9 +150,7 @@ 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

@@ -189,43 +187,6 @@ 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
 {
@@ -246,8 +207,8 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    istrstream(istrstream&& __rhs)
-        : istream(_VSTD::move(__rhs)),
-          __sb_(_VSTD::move(__rhs.__sb_))
+        : istream(_STD::move(__rhs)),
+          __sb_(_STD::move(__rhs.__sb_))
    {
        istream::set_rdbuf(&__sb_);
    }
@@ -255,8 +216,8 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    istrstream& operator=(istrstream&& __rhs)
    {
-        istream::operator=(_VSTD::move(__rhs));
-        __sb_ = _VSTD::move(__rhs.__sb_);
+        istream::operator=(_STD::move(__rhs));
+        __sb_ = _STD::move(__rhs.__sb_);
        return *this;
    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -295,8 +256,8 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    ostrstream(ostrstream&& __rhs)
-        : ostream(_VSTD::move(__rhs)),
-          __sb_(_VSTD::move(__rhs.__sb_))
+        : ostream(_STD::move(__rhs)),
+          __sb_(_STD::move(__rhs.__sb_))
    {
        ostream::set_rdbuf(&__sb_);
    }
@@ -304,8 +265,8 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    ostrstream& operator=(ostrstream&& __rhs)
    {
-        ostream::operator=(_VSTD::move(__rhs));
-        __sb_ = _VSTD::move(__rhs.__sb_);
+        ostream::operator=(_STD::move(__rhs));
+        __sb_ = _STD::move(__rhs.__sb_);
        return *this;
    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -355,8 +316,8 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    strstream(strstream&& __rhs)
-        : iostream(_VSTD::move(__rhs)),
-          __sb_(_VSTD::move(__rhs.__sb_))
+        : iostream(_STD::move(__rhs)),
+          __sb_(_STD::move(__rhs.__sb_))
    {
        iostream::set_rdbuf(&__sb_);
    }
@@ -364,8 +325,8 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    strstream& operator=(strstream&& __rhs)
    {
-        iostream::operator=(_VSTD::move(__rhs));
-        __sb_ = _VSTD::move(__rhs.__sb_);
+        iostream::operator=(_STD::move(__rhs));
+        __sb_ = _STD::move(__rhs.__sb_);
        return *this;
    }
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
--- a/include/support/win32/locale_win32.h
+++ b/include/support/win32/locale_win32.h
@@ -1,110 +0,0 @@
-// -*- C++ -*-
-//===--------------------- support/win32/locale_win32.h -------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
-#define _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
-
-// ctype mask table defined in msvcrt.dll
-extern "C" unsigned short  __declspec(dllimport) _ctype[];
-
-#include "support/win32/support.h"
-#include <memory>
-#include <xlocinfo.h> // _locale_t
-#define locale_t _locale_t
-#define LC_COLLATE_MASK _M_COLLATE
-#define LC_CTYPE_MASK _M_CTYPE
-#define LC_MONETARY_MASK _M_MONETARY
-#define LC_NUMERIC_MASK _M_NUMERIC
-#define LC_TIME_MASK _M_TIME
-#define LC_MESSAGES_MASK _M_MESSAGES
-#define LC_ALL_MASK (  LC_COLLATE_MASK \
-                     | LC_CTYPE_MASK \
-                     | LC_MESSAGES_MASK \
-                     | LC_MONETARY_MASK \
-                     | LC_NUMERIC_MASK \
-                     | LC_TIME_MASK )
-#define freelocale _free_locale
-// FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int mask, const char * locale, locale_t base );
-locale_t uselocale( locale_t newloc );
-lconv *localeconv_l( locale_t loc );
-size_t mbrlen_l( const char *__restrict__ s, size_t n,
-                 mbstate_t *__restrict__ ps, locale_t loc);
-size_t mbsrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                    size_t len, mbstate_t *__restrict__ ps, locale_t loc );
-size_t wcrtomb_l( char *__restrict__ s, wchar_t wc, mbstate_t *__restrict__ ps,
-                  locale_t loc);
-size_t mbrtowc_l( wchar_t *__restrict__ pwc, const char *__restrict__ s,
-                  size_t n, mbstate_t *__restrict__ ps, locale_t loc);
-size_t mbsnrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                     size_t nms, size_t len, mbstate_t *__restrict__ ps, locale_t loc);
-size_t wcsnrtombs_l( char *__restrict__ dst, const wchar_t **__restrict__ src,
-                     size_t nwc, size_t len, mbstate_t *__restrict__ ps, locale_t loc);
-wint_t btowc_l( int c, locale_t loc );
-int wctob_l( wint_t c, locale_t loc );
-typedef _VSTD::remove_pointer<locale_t>::type __locale_struct;
-typedef _VSTD::unique_ptr<__locale_struct, decltype(&uselocale)> __locale_raii;
-_LIBCPP_ALWAYS_INLINE inline
-decltype(MB_CUR_MAX) MB_CUR_MAX_L( locale_t __l )
-{
-  __locale_raii __current( uselocale(__l), uselocale );
-  return MB_CUR_MAX;
-}
-
-// the *_l functions are prefixed on Windows, only available for msvcr80+, VS2005+
-#include <stdio.h>
-#define mbtowc_l _mbtowc_l
-#define strtoll_l _strtoi64_l
-#define strtoull_l _strtoui64_l
-// FIXME: current msvcrt does not know about long double
-#define strtold_l _strtod_l
-#define islower_l _islower_l
-#define isupper_l _isupper_l
-#define isdigit_l _isdigit_l
-#define isxdigit_l _isxdigit_l
-#define strcoll_l _strcoll_l
-#define strxfrm_l _strxfrm_l
-#define wcscoll_l _wcscoll_l
-#define wcsxfrm_l _wcsxfrm_l
-#define toupper_l _toupper_l
-#define tolower_l _tolower_l
-#define iswspace_l _iswspace_l
-#define iswprint_l _iswprint_l
-#define iswcntrl_l _iswcntrl_l
-#define iswupper_l _iswupper_l
-#define iswlower_l _iswlower_l
-#define iswalpha_l _iswalpha_l
-#define iswdigit_l _iswdigit_l
-#define iswpunct_l _iswpunct_l
-#define iswxdigit_l _iswxdigit_l
-#define towupper_l _towupper_l
-#define towlower_l _towlower_l
-#define strftime_l _strftime_l
-#define sscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
-#define vsscanf_l( __s, __l, __f, ...) _sscanf_l( __s, __f, __l, __VA_ARGS__ )
-#define sprintf_l( __s, __l, __f, ... ) _sprintf_l( __s, __f, __l, __VA_ARGS__ )
-#define snprintf_l( __s, __n, __l, __f, ... ) _snprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
-#define vsprintf_l( __s, __l, __f, ... ) _vsprintf_l( __s, __f, __l, __VA_ARGS__ )
-#define vsnprintf_l( __s, __n, __l, __f, ... ) _vsnprintf_l( __s, __n, __f, __l, __VA_ARGS__ )
-int asprintf_l( char **ret, locale_t loc, const char *format, ... );
-int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap );
-
-
-// not-so-pressing FIXME: use locale to determine blank characters
-inline int isblank_l( int c, locale_t /*loc*/ )
-{
-    return ( c == ' ' || c == '\t' );
-}
-inline int iswblank_l( wint_t c, locale_t /*loc*/ )
-{
-    return ( c == L' ' || c == L'\t' );
-}
-
-#endif // _LIBCPP_SUPPORT_WIN32_LOCALE_WIN32_H
--- a/include/support/win32/support.h
+++ b/include/support/win32/support.h
@@ -1,31 +0,0 @@
-// -*- C++ -*-
-//===----------------------- support/win32/support.h ----------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef _LIBCPP_SUPPORT_WIN32_SUPPORT_H
-#define _LIBCPP_SUPPORT_WIN32_SUPPORT_H
-
-/*
-   Functions and constants used in libc++ that are missing from the Windows C library.
-  */
-
-#include <wchar.h>  // mbstate_t
-#include <stdio.h> // _snwprintf
-#define swprintf _snwprintf
-#define vswprintf _vsnwprintf
-
-int vasprintf( char **sptr, const char *__restrict__ fmt , va_list ap );
-int asprintf(char **sptr, const char *__restrict__ fmt, ...);
-
-size_t mbsnrtowcs( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                   size_t nmc, size_t len, mbstate_t *__restrict__ ps );
-size_t wcsnrtombs( char *__restrict__ dst, const wchar_t **__restrict__ src,
-                   size_t nwc, size_t len, mbstate_t *__restrict__ ps );
-
-#endif // _LIBCPP_SUPPORT_WIN32_SUPPORT_H
--- a/include/system_error
+++ b/include/system_error
@@ -20,24 +20,24 @@ namespace std
 class error_category
 {
 public:
-    virtual ~error_category() noexcept;
+    virtual ~error_category();

    error_category(const error_category&) = delete;
    error_category& operator=(const error_category&) = delete;

-    virtual const char* name() const noexcept = 0;
-    virtual error_condition default_error_condition(int ev) const noexcept;
-    virtual bool equivalent(int code, const error_condition& condition) const noexcept;
-    virtual bool equivalent(const error_code& code, int condition) const noexcept;
+    virtual const char* name() const = 0;
+    virtual error_condition default_error_condition(int ev) const;
+    virtual bool equivalent(int code, const error_condition& condition) const;
+    virtual bool equivalent(const error_code& code, int condition) const;
    virtual string message(int ev) const = 0;

-    bool operator==(const error_category& rhs) const noexcept;
-    bool operator!=(const error_category& rhs) const noexcept;
-    bool operator<(const error_category& rhs) const noexcept;
+    bool operator==(const error_category& rhs) const;
+    bool operator!=(const error_category& rhs) const;
+    bool operator<(const error_category& rhs) const;
 };

-const error_category& generic_category() noexcept;
-const error_category& system_category() noexcept;
+const error_category& generic_category();
+const error_category& system_category();

 template <class T> struct is_error_code_enum
    : public false_type {};
@@ -49,27 +49,27 @@ class error_code
 {
 public:
    // constructors:
-    error_code() noexcept;
-    error_code(int val, const error_category& cat) noexcept;
+    error_code();
+    error_code(int val, const error_category& cat);
    template <class ErrorCodeEnum>
-        error_code(ErrorCodeEnum e) noexcept;
+        error_code(ErrorCodeEnum e);

    // modifiers:
-    void assign(int val, const error_category& cat) noexcept;
+    void assign(int val, const error_category& cat);
    template <class ErrorCodeEnum>
-        error_code& operator=(ErrorCodeEnum e) noexcept;
-    void clear() noexcept;
+        error_code& operator=(ErrorCodeEnum e);
+    void clear();

    // observers:
-    int value() const noexcept;
-    const error_category& category() const noexcept;
-    error_condition default_error_condition() const noexcept;
+    int value() const;
+    const error_category& category() const;
+    error_condition default_error_condition() const;
    string message() const;
-    explicit operator bool() const noexcept;
+    explicit operator bool() const;
 };

 // non-member functions:
-bool operator<(const error_code& lhs, const error_code& rhs) noexcept;
+bool operator<(const error_code& lhs, const error_code& rhs);
 template <class charT, class traits>
    basic_ostream<charT,traits>&
    operator<<(basic_ostream<charT,traits>& os, const error_code& ec);
@@ -78,25 +78,25 @@ class error_condition
 {
 public:
    // constructors:
-    error_condition() noexcept;
-    error_condition(int val, const error_category& cat) noexcept;
+    error_condition();
+    error_condition(int val, const error_category& cat);
    template <class ErrorConditionEnum>
-        error_condition(ErrorConditionEnum e) noexcept;
+        error_condition(ErrorConditionEnum e);

    // modifiers:
-    void assign(int val, const error_category& cat) noexcept;
+    void assign(int val, const error_category& cat);
    template <class ErrorConditionEnum>
-        error_condition& operator=(ErrorConditionEnum e) noexcept;
-    void clear() noexcept;
+        error_condition& operator=(ErrorConditionEnum e);
+    void clear();

    // observers:
-    int value() const noexcept;
-    const error_category& category() const noexcept;
-    string message() const noexcept;
-    explicit operator bool() const noexcept;
+    int value() const;
+    const error_category& category() const;
+    string message() const;
+    explicit operator bool() const;
 };

-bool operator<(const error_condition& lhs, const error_condition& rhs) noexcept;
+bool operator<(const error_condition& lhs, const error_condition& rhs);

 class system_error
    : public runtime_error
@@ -109,8 +109,8 @@ public:
    system_error(int ev, const error_category& ecat, const char* what_arg);
    system_error(int ev, const error_category& ecat);

-    const error_code& code() const noexcept;
-    const char* what() const noexcept;
+    const error_code& code() const throw();
+    const char* what() const throw();
 };

 enum class errc
@@ -198,18 +198,18 @@ enum class errc
 template <> struct is_error_condition_enum<errc>
    : true_type { }

-error_code make_error_code(errc e) noexcept;
-error_condition make_error_condition(errc e) noexcept;
+error_code make_error_code(errc e);
+error_condition make_error_condition(errc e);

 // Comparison operators:
-bool operator==(const error_code& lhs, const error_code& rhs) noexcept;
-bool operator==(const error_code& lhs, const error_condition& rhs) noexcept;
-bool operator==(const error_condition& lhs, const error_code& rhs) noexcept;
-bool operator==(const error_condition& lhs, const error_condition& rhs) noexcept;
-bool operator!=(const error_code& lhs, const error_code& rhs) noexcept;
-bool operator!=(const error_code& lhs, const error_condition& rhs) noexcept;
-bool operator!=(const error_condition& lhs, const error_code& rhs) noexcept;
-bool operator!=(const error_condition& lhs, const error_condition& rhs) noexcept;
+bool operator==(const error_code& lhs, const error_code& rhs);
+bool operator==(const error_code& lhs, const error_condition& rhs);
+bool operator==(const error_condition& lhs, const error_code& rhs);
+bool operator==(const error_condition& lhs, const error_condition& rhs);
+bool operator!=(const error_code& lhs, const error_code& rhs);
+bool operator!=(const error_code& lhs, const error_condition& rhs);
+bool operator!=(const error_condition& lhs, const error_code& rhs);
+bool operator!=(const error_condition& lhs, const error_condition& rhs);

 template <> struct hash<std::error_code>;

@@ -369,28 +369,28 @@ class __do_message;
 class _LIBCPP_VISIBLE error_category
 {
 public:
-    virtual ~error_category() _NOEXCEPT;
+    virtual ~error_category();

 private:
-    error_category() _NOEXCEPT;
+    error_category();
    error_category(const error_category&);// = delete;
    error_category& operator=(const error_category&);// = delete;

 public:
-    virtual const char* name() const _NOEXCEPT = 0;
-    virtual error_condition default_error_condition(int __ev) const _NOEXCEPT;
-    virtual bool equivalent(int __code, const error_condition& __condition) const _NOEXCEPT;
-    virtual bool equivalent(const error_code& __code, int __condition) const _NOEXCEPT;
+    virtual const char* name() const = 0;
+    virtual error_condition default_error_condition(int __ev) const;
+    virtual bool equivalent(int __code, const error_condition& __condition) const;
+    virtual bool equivalent(const error_code& __code, int __condition) const;
    virtual string message(int __ev) const = 0;

    _LIBCPP_ALWAYS_INLINE
-    bool operator==(const error_category& __rhs) const _NOEXCEPT {return this == &__rhs;}
+    bool operator==(const error_category& __rhs) const {return this == &__rhs;}

    _LIBCPP_ALWAYS_INLINE
-    bool operator!=(const error_category& __rhs) const _NOEXCEPT {return !(*this == __rhs);}
+    bool operator!=(const error_category& __rhs) const {return !(*this == __rhs);}

    _LIBCPP_ALWAYS_INLINE
-    bool operator< (const error_category& __rhs) const _NOEXCEPT {return this < &__rhs;}
+    bool operator< (const error_category& __rhs) const {return this < &__rhs;}

    friend class __do_message;
 };
@@ -402,8 +402,8 @@ public:
    virtual string message(int ev) const;
 };

-const error_category& generic_category() _NOEXCEPT;
-const error_category& system_category() _NOEXCEPT;
+const error_category& generic_category();
+const error_category& system_category();

 class _LIBCPP_VISIBLE error_condition
 {
@@ -411,21 +411,19 @@ class _LIBCPP_VISIBLE error_condition
    const error_category* __cat_;
 public:
    _LIBCPP_ALWAYS_INLINE
-    error_condition() _NOEXCEPT : __val_(0), __cat_(&generic_category()) {}
+    error_condition() : __val_(0), __cat_(&generic_category()) {}

    _LIBCPP_ALWAYS_INLINE
-    error_condition(int __val, const error_category& __cat) _NOEXCEPT
+    error_condition(int __val, const error_category& __cat)
        : __val_(__val), __cat_(&__cat) {}

    template <class _E>
        _LIBCPP_ALWAYS_INLINE
-        error_condition(_E __e,
-              typename enable_if<is_error_condition_enum<_E>::value>::type* = 0
-                                                                     ) _NOEXCEPT
+        error_condition(_E __e, typename enable_if<is_error_condition_enum<_E>::value>::type* = 0)
            {*this = make_error_condition(__e);}

    _LIBCPP_ALWAYS_INLINE
-    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    void assign(int __val, const error_category& __cat)
    {
        __val_ = __val;
        __cat_ = &__cat;
@@ -438,38 +436,38 @@ public:
            is_error_condition_enum<_E>::value,
            error_condition&
        >::type
-        operator=(_E __e) _NOEXCEPT
+        operator=(_E __e)
            {*this = make_error_condition(__e); return *this;}

    _LIBCPP_ALWAYS_INLINE
-    void clear() _NOEXCEPT
+    void clear()
    {
        __val_ = 0;
        __cat_ = &generic_category();
    }

    _LIBCPP_ALWAYS_INLINE
-    int value() const _NOEXCEPT {return __val_;}
+    int value() const {return __val_;}

    _LIBCPP_ALWAYS_INLINE
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
+    const error_category& category() const {return *__cat_;}
    string message() const;

    _LIBCPP_ALWAYS_INLINE
    //explicit
-        operator bool() const _NOEXCEPT {return __val_ != 0;}
+        operator bool() const {return __val_ != 0;}
 };

 inline _LIBCPP_INLINE_VISIBILITY
 error_condition
-make_error_condition(errc __e) _NOEXCEPT
+make_error_condition(errc __e)
 {
    return error_condition(static_cast<int>(__e), generic_category());
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+operator<(const error_condition& __x, const error_condition& __y)
 {
    return __x.category() < __y.category()
        || __x.category() == __y.category() && __x.value() < __y.value();
@@ -483,21 +481,19 @@ class _LIBCPP_VISIBLE error_code
    const error_category* __cat_;
 public:
    _LIBCPP_ALWAYS_INLINE
-    error_code() _NOEXCEPT : __val_(0), __cat_(&system_category()) {}
+    error_code() : __val_(0), __cat_(&system_category()) {}

    _LIBCPP_ALWAYS_INLINE
-    error_code(int __val, const error_category& __cat) _NOEXCEPT
+    error_code(int __val, const error_category& __cat)
        : __val_(__val), __cat_(&__cat) {}

    template <class _E>
        _LIBCPP_ALWAYS_INLINE
-        error_code(_E __e,
-                   typename enable_if<is_error_code_enum<_E>::value>::type* = 0
-                                                                     ) _NOEXCEPT
+        error_code(_E __e, typename enable_if<is_error_code_enum<_E>::value>::type* = 0)
            {*this = make_error_code(__e);}

    _LIBCPP_ALWAYS_INLINE
-    void assign(int __val, const error_category& __cat) _NOEXCEPT
+    void assign(int __val, const error_category& __cat)
    {
        __val_ = __val;
        __cat_ = &__cat;
@@ -510,43 +506,43 @@ public:
            is_error_code_enum<_E>::value,
            error_code&
        >::type
-        operator=(_E __e) _NOEXCEPT
+        operator=(_E __e)
            {*this = make_error_code(__e); return *this;}

    _LIBCPP_ALWAYS_INLINE
-    void clear() _NOEXCEPT
+    void clear()
    {
        __val_ = 0;
        __cat_ = &system_category();
    }

    _LIBCPP_ALWAYS_INLINE
-    int value() const _NOEXCEPT {return __val_;}
+    int value() const {return __val_;}

    _LIBCPP_ALWAYS_INLINE
-    const error_category& category() const _NOEXCEPT {return *__cat_;}
+    const error_category& category() const {return *__cat_;}

    _LIBCPP_ALWAYS_INLINE
-    error_condition default_error_condition() const _NOEXCEPT
+    error_condition default_error_condition() const
        {return __cat_->default_error_condition(__val_);}

    string message() const;

    _LIBCPP_ALWAYS_INLINE
    //explicit
-        operator bool() const _NOEXCEPT {return __val_ != 0;}
+        operator bool() const {return __val_ != 0;}
 };

 inline _LIBCPP_INLINE_VISIBILITY
 error_code
-make_error_code(errc __e) _NOEXCEPT
+make_error_code(errc __e)
 {
    return error_code(static_cast<int>(__e), generic_category());
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator<(const error_code& __x, const error_code& __y) _NOEXCEPT
+operator<(const error_code& __x, const error_code& __y)
 {
    return __x.category() < __y.category()
        || __x.category() == __y.category() && __x.value() < __y.value();
@@ -554,14 +550,14 @@ operator<(const error_code& __x, const error_code& __y) _NOEXCEPT

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_code& __x, const error_code& __y) _NOEXCEPT
+operator==(const error_code& __x, const error_code& __y)
 {
    return __x.category() == __y.category() && __x.value() == __y.value();
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT
+operator==(const error_code& __x, const error_condition& __y)
 {
    return __x.category().equivalent(__x.value(), __y)
        || __y.category().equivalent(__x, __y.value());
@@ -569,44 +565,40 @@ operator==(const error_code& __x, const error_condition& __y) _NOEXCEPT

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_condition& __x, const error_code& __y) _NOEXCEPT
+operator==(const error_condition& __x, const error_code& __y)
 {
    return __y == __x;
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator==(const error_condition& __x, const error_condition& __y) _NOEXCEPT
+operator==(const error_condition& __x, const error_condition& __y)
 {
    return __x.category() == __y.category() && __x.value() == __y.value();
 }

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_code& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_code& __x, const error_code& __y) {return !(__x == __y);}

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_code& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_code& __x, const error_condition& __y) {return !(__x == __y);}

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_condition& __x, const error_code& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_condition& __x, const error_code& __y) {return !(__x == __y);}

 inline _LIBCPP_INLINE_VISIBILITY
 bool
-operator!=(const error_condition& __x, const error_condition& __y) _NOEXCEPT
-{return !(__x == __y);}
+operator!=(const error_condition& __x, const error_condition& __y) {return !(__x == __y);}

 template <>
 struct _LIBCPP_VISIBLE hash<error_code>
    : public unary_function<error_code, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(const error_code& __ec) const _NOEXCEPT
+    size_t operator()(const error_code& __ec) const
    {
        return static_cast<size_t>(__ec.value());
    }
@@ -625,10 +617,10 @@ public:
    system_error(int __ev, const error_category& __ecat, const string& __what_arg);
    system_error(int __ev, const error_category& __ecat, const char* __what_arg);
    system_error(int __ev, const error_category& __ecat);
-    ~system_error() _NOEXCEPT;
+    ~system_error() throw();

    _LIBCPP_ALWAYS_INLINE
-    const error_code& code() const _NOEXCEPT {return __ec_;}
+    const error_code& code() const throw() {return __ec_;}

 private:
    static string __init(const error_code&, string);
--- a/include/thread
+++ b/include/thread
@@ -284,7 +284,7 @@ public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY
-    void swap(thread& __t) {_VSTD::swap(__t_, __t.__t_);}
+    void swap(thread& __t) {_STD::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(_VSTD::move(_VSTD::get<0>(__t)), _VSTD::move(_VSTD::get<_Indices>(__t))...);
+    __invoke(_STD::move(_STD::get<0>(__t)), _STD::move(_STD::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;
-    _VSTD::unique_ptr<_G> __p(new _G(__decay_copy(_VSTD::forward<_F>(__f)),
-                                __decay_copy(_VSTD::forward<_Args>(__args))...));
+    _STD::unique_ptr<_G> __p(new _G(__decay_copy(_STD::forward<_F>(__f)),
+                                __decay_copy(_STD::forward<_Args>(__args))...));
    int __ec = pthread_create(&__t_, 0, &__thread_proxy<_G>, __p.get());
    if (__ec == 0)
        __p.release();
--- a/include/tuple
+++ b/include/tuple
@@ -25,7 +25,7 @@ public:
    template <class... U>
        explicit tuple(U&&...);
    tuple(const tuple&) = default;
-    tuple(tuple&&) = default;
+    tuple(tuple&&);
    template <class... U>
        tuple(const tuple<U...>&);
    template <class... U>
@@ -56,8 +56,7 @@ public:
        tuple(allocator_arg_t, const Alloc& a, pair<U1, U2>&&);

    tuple& operator=(const tuple&);
-    tuple&
-        operator=(tuple&&) noexcept(AND(is_nothrow_move_assignable<T>::value ...));
+    tuple& operator=(tuple&&);
    template <class... U>
        tuple& operator=(const tuple<U...>&);
    template <class... U>
@@ -67,14 +66,14 @@ public:
    template <class U1, class U2>
        tuple& operator=(pair<U1, U2>&&); //iffsizeof...(T) == 2

-    void swap(tuple&) noexcept(AND(swap(declval<T&>(), declval<T&>())...));
+    void swap(tuple&);
 };

 const unspecified ignore;

 template <class... T> tuple<V...>  make_tuple(T&&...);
-template <class... T> tuple<ATypes...> forward_as_tuple(T&&...) noexcept;
-template <class... T> tuple<T&...> tie(T&...) noexcept;
+template <class... T> tuple<ATypes...> forward_as_tuple(T&&...);
+template <class... T> tuple<T&...> tie(T&...);
 template <class... Tuples> tuple<CTypes...> tuple_cat(Tuples&&... tpls);
  
 // 20.4.1.4, tuple helper classes:
@@ -84,15 +83,9 @@ template <intsize_t I, class T> class tuple_element; // undefined
 template <intsize_t I, class... T> class tuple_element<I, tuple<T...>>;

 // 20.4.1.5, element access:
-template <intsize_t I, class... T>
-    typename tuple_element<I, tuple<T...>>::type&
-    get(tuple<T...>&) noexcept;
-template <intsize_t I, class... T>
-    typename tuple_element<I, tuple<T...>>::type const&
-    get(const tuple<T...>&) noexcept;
-template <intsize_t I, class... T>
-    typename tuple_element<I, tuple<T...>>::type&&
-    get(tuple<T...>&&) noexcept;
+template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type& get(tuple<T...>&);
+template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type const& get(const tuple<T...>&);
+template <intsize_t I, class... T> typename tuple_element<I, tuple<T...>>::type&& get(tuple<T...>&&);

 // 20.4.1.6, relational operators:
 template<class... T, class... U> bool operator==(const tuple<T...>&, const tuple<U...>&);
@@ -106,8 +99,7 @@ template <class... Types, class Alloc>
  struct uses_allocator<tuple<Types...>, Alloc>;

 template <class... Types>
-  void
-  swap(tuple<Types...>& x, tuple<Types...>& y) noexcept(noexcept(x.swap(y)));
+  void swap(tuple<Types...>& x, tuple<Types...>& y);

 }  // std

@@ -150,7 +142,6 @@ class __tuple_leaf;
 template <size_t _Ip, class _Hp, bool _Ep>
 inline _LIBCPP_INLINE_VISIBILITY
 void swap(__tuple_leaf<_Ip, _Hp, _Ep>& __x, __tuple_leaf<_Ip, _Hp, _Ep>& __y)
-    _NOEXCEPT_(__is_nothrow_swappable<_Hp>::value)
 {
    swap(__x.get(), __y.get());
 }
@@ -191,7 +182,7 @@ public:
              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tuple_leaf(_Tp&& __t)
-            : value(_VSTD::forward<_Tp>(__t))
+            : value(_STD::forward<_Tp>(__t))
        {static_assert(!is_reference<_Hp>::value ||
                        is_lvalue_reference<_Hp>::value &&
                        (is_lvalue_reference<_Tp>::value ||
@@ -207,7 +198,7 @@ public:
    template <class _Tp, class _Alloc>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
-            : value(_VSTD::forward<_Tp>(__t))
+            : value(_STD::forward<_Tp>(__t))
        {static_assert(!is_lvalue_reference<_Hp>::value ||
                        is_lvalue_reference<_Hp>::value &&
                        (is_lvalue_reference<_Tp>::value ||
@@ -221,7 +212,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, _VSTD::forward<_Tp>(__t))
+            : value(allocator_arg_t(), __a, _STD::forward<_Tp>(__t))
        {static_assert(!is_lvalue_reference<_Hp>::value ||
                        is_lvalue_reference<_Hp>::value &&
                        (is_lvalue_reference<_Tp>::value ||
@@ -235,7 +226,7 @@ public:
    template <class _Tp, class _Alloc>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
-            : value(_VSTD::forward<_Tp>(__t), __a)
+            : value(_STD::forward<_Tp>(__t), __a)
        {static_assert(!is_lvalue_reference<_Hp>::value ||
                        is_lvalue_reference<_Hp>::value &&
                        (is_lvalue_reference<_Tp>::value ||
@@ -260,14 +251,14 @@ public:
        __tuple_leaf&
        operator=(_Tp&& __t)
        {
-            value = _VSTD::forward<_Tp>(__t);
+            value = _STD::forward<_Tp>(__t);
            return *this;
        }

    _LIBCPP_INLINE_VISIBILITY
-    int swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
+    int swap(__tuple_leaf& __t)
    {
-        _VSTD::swap(*this, __t);
+        _STD::swap(*this, __t);
        return 0;
    }

@@ -302,22 +293,22 @@ public:
              class = typename enable_if<is_constructible<_Hp, _Tp>::value>::type>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tuple_leaf(_Tp&& __t)
-            : _Hp(_VSTD::forward<_Tp>(__t)) {}
+            : _Hp(_STD::forward<_Tp>(__t)) {}

    template <class _Tp, class _Alloc>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tuple_leaf(integral_constant<int, 0>, const _Alloc&, _Tp&& __t)
-            : _Hp(_VSTD::forward<_Tp>(__t)) {}
+            : _Hp(_STD::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, _VSTD::forward<_Tp>(__t)) {}
+            : _Hp(allocator_arg_t(), __a, _STD::forward<_Tp>(__t)) {}

    template <class _Tp, class _Alloc>
        _LIBCPP_INLINE_VISIBILITY
        explicit __tuple_leaf(integral_constant<int, 2>, const _Alloc& __a, _Tp&& __t)
-            : _Hp(_VSTD::forward<_Tp>(__t), __a) {}
+            : _Hp(_STD::forward<_Tp>(__t), __a) {}

    template <class _Tp>
        _LIBCPP_INLINE_VISIBILITY
@@ -329,15 +320,13 @@ public:
        __tuple_leaf&
        operator=(_Tp&& __t)
        {
-            _Hp::operator=(_VSTD::forward<_Tp>(__t));
+            _Hp::operator=(_STD::forward<_Tp>(__t));
            return *this;
        }

-    _LIBCPP_INLINE_VISIBILITY
-    int
-    swap(__tuple_leaf& __t) _NOEXCEPT_(__is_nothrow_swappable<__tuple_leaf>::value)
+    _LIBCPP_INLINE_VISIBILITY int swap(__tuple_leaf& __t)
    {
-        _VSTD::swap(*this, __t);
+        _STD::swap(*this, __t);
        return 0;
    }

@@ -349,20 +338,6 @@ template <class ..._Tp>
 _LIBCPP_INLINE_VISIBILITY
 void __swallow(_Tp&&...) {}

-template <bool ...> struct __all;
-
-template <>
-struct __all<>
-{
-    static const bool value = true;
-};
-
-template <bool _B0, bool ... _B>
-struct __all<_B0, _B...>
-{
-    static const bool value = _B0 && __all<_B...>::value;
-};
-
 // __tuple_impl

 template<class _Indx, class ..._Tp> struct __tuple_impl;
@@ -378,7 +353,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>(_VSTD::forward<_Up>(__u))...,
+            __tuple_leaf<_Uf, _Tf>(_STD::forward<_Up>(__u))...,
            __tuple_leaf<_Ul, _Tl>()...
            {}

@@ -391,7 +366,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,
-            _VSTD::forward<_Up>(__u))...,
+            _STD::forward<_Up>(__u))...,
            __tuple_leaf<_Ul, _Tl>(__uses_alloc_ctor<_Tl, _Alloc>(), __a)...
            {}

@@ -403,8 +378,8 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
             >
        _LIBCPP_INLINE_VISIBILITY
        __tuple_impl(_Tuple&& __t)
-            : __tuple_leaf<_Indx, _Tp>(_VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
+            : __tuple_leaf<_Indx, _Tp>(_STD::forward<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
            {}

    template <class _Alloc, class _Tuple,
@@ -417,8 +392,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,
-                                       _VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...
+                                       _STD::forward<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...
            {}

    template <class _Tuple>
@@ -430,14 +405,13 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
        >::type
        operator=(_Tuple&& __t)
        {
-            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_VSTD::forward<typename tuple_element<_Indx,
-                                       typename __make_tuple_types<_Tuple>::type>::type>(_VSTD::get<_Indx>(__t)))...);
+            __swallow(__tuple_leaf<_Indx, _Tp>::operator=(_STD::forward<typename tuple_element<_Indx,
+                                       typename __make_tuple_types<_Tuple>::type>::type>(_STD::get<_Indx>(__t)))...);
            return *this;
        }

    _LIBCPP_INLINE_VISIBILITY
    void swap(__tuple_impl& __t)
-        _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
    {
        __swallow(__tuple_leaf<_Indx, _Tp>::swap(static_cast<__tuple_leaf<_Indx, _Tp>&>(__t))...);
    }
@@ -499,7 +473,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(),
-                    _VSTD::forward<_Up>(__u)...) {}
+                    _STD::forward<_Up>(__u)...) {}

    template <class _Alloc, class ..._Up,
              class = typename enable_if
@@ -522,7 +496,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(),
-                    _VSTD::forward<_Up>(__u)...) {}
+                    _STD::forward<_Up>(__u)...) {}

    template <class _Tuple,
              class = typename enable_if
@@ -532,7 +506,7 @@ public:
             >
        _LIBCPP_INLINE_VISIBILITY
        tuple(_Tuple&& __t)
-            : base_(_VSTD::forward<_Tuple>(__t)) {}
+            : base_(_STD::forward<_Tuple>(__t)) {}

    template <class _Alloc, class _Tuple,
              class = typename enable_if
@@ -542,7 +516,7 @@ public:
             >
        _LIBCPP_INLINE_VISIBILITY
        tuple(allocator_arg_t, const _Alloc& __a, _Tuple&& __t)
-            : base_(allocator_arg_t(), __a, _VSTD::forward<_Tuple>(__t)) {}
+            : base_(allocator_arg_t(), __a, _STD::forward<_Tuple>(__t)) {}

    template <class _Tuple,
              class = typename enable_if
@@ -554,13 +528,12 @@ public:
        tuple&
        operator=(_Tuple&& __t)
        {
-            base_.operator=(_VSTD::forward<_Tuple>(__t));
+            base_.operator=(_STD::forward<_Tuple>(__t));
            return *this;
        }

    _LIBCPP_INLINE_VISIBILITY
-    void swap(tuple& __t) _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-        {base_.swap(__t.base_);}
+    void swap(tuple& __t) {base_.swap(__t.base_);}
 };

 template <>
@@ -582,19 +555,13 @@ public:
    _LIBCPP_INLINE_VISIBILITY
        tuple(allocator_arg_t, const _Alloc&, array<_U, 0>) {}
    _LIBCPP_INLINE_VISIBILITY
-    void swap(tuple&) _NOEXCEPT {}
+    void swap(tuple&) {}
 };

 template <class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __all<__is_swappable<_Tp>::value...>::value,
-    void
->::type
-swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u)
-                 _NOEXCEPT_(__all<__is_nothrow_swappable<_Tp>::value...>::value)
-    {__t.swap(__u);}
+void
+swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) {__t.swap(__u);}

 // get

@@ -639,6 +606,11 @@ tie(_Tp&... __t)
 template <class _Up>
 struct __ignore_t
 {
+    _LIBCPP_INLINE_VISIBILITY
+    __ignore_t() {}
+    template <class _Tp>
+        _LIBCPP_INLINE_VISIBILITY
+        __ignore_t(_Tp&&) {}
    template <class _Tp>
        _LIBCPP_INLINE_VISIBILITY
        const __ignore_t& operator=(_Tp&&) const {return *this;}
@@ -671,7 +643,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 tuple<typename __make_tuple_return<_Tp>::type...>
 make_tuple(_Tp&&... __t)
 {
-    return tuple<typename __make_tuple_return<_Tp>::type...>(_VSTD::forward<_Tp>(__t)...);
+    return tuple<typename __make_tuple_return<_Tp>::type...>(_STD::forward<_Tp>(__t)...);
 }

 template <class... _Tp>
@@ -679,7 +651,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 tuple<_Tp&&...>
 forward_as_tuple(_Tp&&... __t)
 {
-    return tuple<_Tp&&...>(_VSTD::forward<_Tp>(__t)...);
+    return tuple<_Tp&&...>(_STD::forward<_Tp>(__t)...);
 }

 template <size_t _I>
@@ -877,8 +849,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 _VSTD::forward_as_tuple(_VSTD::forward<_Types>(get<_I0>(__t))...,
-                                      get<_J0>(_VSTD::forward<_Tuple0>(__t0))...);
+        return _STD::forward_as_tuple(_STD::forward<_Types>(get<_I0>(__t))...,
+                                      get<_J0>(_STD::forward<_Tuple0>(__t0))...);
    }

    template <class _Tuple0, class _Tuple1, class ..._Tuples>
@@ -892,12 +864,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>()
-                           (_VSTD::forward_as_tuple(
-                              _VSTD::forward<_Types>(get<_I0>(__t))...,
-                              get<_J0>(_VSTD::forward<_Tuple0>(__t0))...
+                           (_STD::forward_as_tuple(
+                              _STD::forward<_Types>(get<_I0>(__t))...,
+                              get<_J0>(_STD::forward<_Tuple0>(__t0))...
                            ),
-                            _VSTD::forward<_Tuple1>(__t1),
-                            _VSTD::forward<_Tuples>(__tpls)...);
+                            _STD::forward<_Tuple1>(__t1),
+                            _STD::forward<_Tuples>(__tpls)...);
    }
 };

@@ -909,8 +881,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<>(), _VSTD::forward<_Tuple0>(__t0),
-                                            _VSTD::forward<_Tuples>(__tpls)...);
+                  (tuple<>(), _STD::forward<_Tuple0>(__t0),
+                                            _STD::forward<_Tuples>(__tpls)...);
 }

 template <class ..._Tp, class _Alloc>
@@ -923,8 +895,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(_VSTD::forward<_Args1>(get<_I1>( __first_args))...),
-      second(_VSTD::forward<_Args2>(get<_I2>(__second_args))...)
+    :  first(_STD::forward<_Args1>(get<_I1>( __first_args))...),
+      second(_STD::forward<_Args2>(get<_I2>(__second_args))...)
 {
 }

--- a/include/type_traits
+++ b/include/type_traits
@@ -328,11 +328,6 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_class

 #endif

-// is_same
-
-template <class _Tp, class _Up> struct _LIBCPP_VISIBLE is_same           : public false_type {};
-template <class _Tp>            struct _LIBCPP_VISIBLE is_same<_Tp, _Tp> : public true_type {};
-
 // is_function

 namespace __is_function_imp
@@ -345,8 +340,7 @@ template <class _Tp> _Tp&  __source();
 template <class _Tp, bool = is_class<_Tp>::value ||
                            is_union<_Tp>::value ||
                            is_void<_Tp>::value  ||
-                            is_reference<_Tp>::value ||
-                            is_same<_Tp, nullptr_t>::value >
+                            is_reference<_Tp>::value>
 struct __is_function
    : public integral_constant<bool, sizeof(__is_function_imp::__test<_Tp>(__is_function_imp::__source<_Tp>())) == 1>
    {};
@@ -597,6 +591,11 @@ template <class _Tp> struct _LIBCPP_VISIBLE remove_all_extents<_Tp[]>
 template <class _Tp, size_t _Np> struct _LIBCPP_VISIBLE remove_all_extents<_Tp[_Np]>
    {typedef typename remove_all_extents<_Tp>::type type;};

+// is_same
+
+template <class _Tp, class _Up> struct _LIBCPP_VISIBLE is_same           : public false_type {};
+template <class _Tp>            struct _LIBCPP_VISIBLE is_same<_Tp, _Tp> : public true_type {};
+
 // is_abstract

 namespace __is_abstract_imp
@@ -725,7 +724,7 @@ template <class _T1, class _T2> struct _LIBCPP_VISIBLE is_convertible

 // is_base_of

-#ifdef _LIBCP_HAS_IS_BASE_OF
+#if __has_feature(is_base_of)

 template <class _Bp, class _Dp>
 struct _LIBCPP_VISIBLE is_base_of
@@ -733,7 +732,51 @@ struct _LIBCPP_VISIBLE is_base_of

 #else  // __has_feature(is_base_of)

-#error is_base_of not implemented.
+//  (C) Copyright Rani Sharoni 2003.
+//  Use, modification and distribution are subject to the Boost Software License,
+//  Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+//  http://www.boost.org/LICENSE_1_0.txt).
+//
+//  See http://www.boost.org/libs/type_traits for most recent version including documentation.
+
+template <class _Bp, class _Dp>
+struct __is_base_of_tests
+{
+    template <class _Tp>
+    static char  __test(const volatile _Dp*, _Tp);
+    static __two __test(const volatile _Bp*, int);
+};
+
+template <class _Bp, class _Dp>
+struct __is_base_of_imp
+{
+    struct __host
+    {
+        operator const volatile _Bp*() const;
+        operator const volatile _Dp*();
+    };
+
+    static const size_t __complete_check = sizeof(_Dp);
+    static const bool value = sizeof(__is_base_of_tests<_Bp, _Dp>::__test(__host(), 0)) == 1;
+};
+
+template <class _Bp, class _Dp, bool = is_class<_Bp>::value,
+                                bool = is_class<_Dp>::value,
+                                bool = is_same<_Bp, _Dp>::value>
+struct __libcpp_base_of : public false_type {};
+
+template <class _Bp, class _Dp>
+struct __libcpp_base_of<_Bp, _Dp, true, true, true> : public true_type {};
+
+template <class _Bp, class _Dp>
+struct __libcpp_base_of<_Bp, _Dp, true, true, false>
+    : public integral_constant<bool, __is_base_of_imp<_Bp, _Dp>::value> {};
+
+template <class _Bp, class _Dp>
+struct _LIBCPP_VISIBLE is_base_of
+    : public __libcpp_base_of<typename remove_cv<_Bp>::type, typename remove_cv<_Dp>::type>
+{
+};

 #endif  // __has_feature(is_base_of)

@@ -774,7 +817,7 @@ template <class _Tp> struct _LIBCPP_VISIBLE is_polymorphic

 // has_virtual_destructor

-#if __has_feature(has_virtual_destructor) || (__GNUC__ > 4) || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)
+#ifdef __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)> {};
@@ -1164,7 +1207,7 @@ struct _LIBCPP_VISIBLE common_type<_Tp, _Up, _Vp...>
 // is_assignable

 template <class _Tp, class _Arg>
-decltype((_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>(), true_type()))
+decltype((_STD::declval<_Tp>() = _STD::declval<_Arg>(), true_type()))
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __is_assignable_test(_Tp&&, _Arg&&);
 #else
@@ -1221,7 +1264,7 @@ struct __destructible_test
 };

 template <class _Tp>
-decltype((_VSTD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
+decltype((_STD::declval<__destructible_test<_Tp> >().~__destructible_test<_Tp>(), true_type()))
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 __is_destructible_test(_Tp&&);
 #else
@@ -1253,7 +1296,7 @@ struct is_destructible
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename remove_reference<_Tp>::type&&
-move(_Tp&& __t) _NOEXCEPT
+move(_Tp&& __t)
 {
    typedef typename remove_reference<_Tp>::type _Up;
    return static_cast<_Up&&>(__t);
@@ -1262,7 +1305,7 @@ move(_Tp&& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp&&
-forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
+forward(typename std::remove_reference<_Tp>::type& __t)
 {
    return static_cast<_Tp&&>(__t);
 }
@@ -1270,7 +1313,7 @@ forward(typename std::remove_reference<_Tp>::type& __t) _NOEXCEPT
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 _Tp&&
-forward(typename std::remove_reference<_Tp>::type&& __t) _NOEXCEPT
+forward(typename std::remove_reference<_Tp>::type&& __t)
 {
 	static_assert(!std::is_lvalue_reference<_Tp>::value,
 	              "Can not forward an rvalue as an lvalue.");
@@ -1384,28 +1427,14 @@ 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 _VSTD::forward<_Tp>(__t);
+    return _STD::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
 {
@@ -1636,7 +1665,7 @@ struct __member_pointer_traits

 // result_of

-template <class _Callable> class result_of;
+template <class> class result_of;

 template <class _Fn, bool, bool>
 class __result_of
@@ -1671,7 +1700,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(*_VSTD::declval<_Tp>()), _R>::type&& type;
+    typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type&& type;
 };

 template <class _R, class _Class, class _Tp>
@@ -1756,7 +1785,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(*_VSTD::declval<_Tp>()), _R>::type& type;
+    typedef typename __apply_cv<decltype(*_STD::declval<_Tp>()), _R>::type& type;
 };

 template <class _R, class _Class, class _Tp>
@@ -1857,7 +1886,7 @@ class _LIBCPP_VISIBLE result_of<_Fn(_A0, _A1, _A2)>
 //      main is_constructible test

 template <class _Tp, class ..._Args>
-decltype(_VSTD::move(_Tp(_VSTD::declval<_Args>()...)), true_type())
+decltype(_STD::move(_Tp(_STD::declval<_Args>()...)), true_type())
 __is_constructible_test(_Tp&&, _Args&& ...);

 template <class ..._Args>
@@ -1984,7 +2013,7 @@ false_type
 __is_constructible0_test(__any);

 template <class _Tp, class _A0>
-decltype((_Tp(_VSTD::declval<_A0>()), true_type()))
+decltype((_Tp(_STD::declval<_A0>()), true_type()))
 __is_constructible1_test(_Tp&, _A0&);

 template <class _A0>
@@ -1992,7 +2021,7 @@ false_type
 __is_constructible1_test(__any, _A0&);

 template <class _Tp, class _A0, class _A1>
-decltype((_Tp(_VSTD::declval<_A0>(), _VSTD::declval<_A1>()), true_type()))
+decltype((_Tp(_STD::declval<_A0>(), _STD::declval<_A1>()), true_type()))
 __is_constructible2_test(_Tp&, _A0&, _A1&);

 template <class _A0, class _A1>
@@ -2564,7 +2593,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(_VSTD::declval<_Tp>() = _VSTD::declval<_Arg>()) >
+    : public integral_constant<bool, noexcept(_STD::declval<_Tp>() = _STD::declval<_Arg>()) >
 {
 };

@@ -2650,7 +2679,7 @@ struct __is_nothrow_destructible<false, _Tp>

 template <class _Tp>
 struct __is_nothrow_destructible<true, _Tp>
-    : public integral_constant<bool, noexcept(_VSTD::declval<_Tp>().~_Tp()) >
+    : public integral_constant<bool, noexcept(_STD::declval<_Tp>().~_Tp()) >
 {
 };

@@ -2902,31 +2931,31 @@ __invoke(__any, _Args&& ...__args)
 template <class _F, class _A0, class ..._Args>
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype((_VSTD::forward<_A0>(__a0).*__f)(_VSTD::forward<_Args>(__args)...));
+    -> decltype((_STD::forward<_A0>(__a0).*__f)(_STD::forward<_Args>(__args)...));

 template <class _F, class _A0, class ..._Args>
 auto
 __invoke(_F&& __f, _A0&& __a0, _Args&& ...__args)
-    -> decltype(((*_VSTD::forward<_A0>(__a0)).*__f)(_VSTD::forward<_Args>(__args)...));
+    -> decltype(((*_STD::forward<_A0>(__a0)).*__f)(_STD::forward<_Args>(__args)...));

 // bullets 3 and 4

 template <class _F, class _A0>
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype(_VSTD::forward<_A0>(__a0).*__f);
+    -> decltype(_STD::forward<_A0>(__a0).*__f);

 template <class _F, class _A0>
 auto
 __invoke(_F&& __f, _A0&& __a0)
-    -> decltype((*_VSTD::forward<_A0>(__a0)).*__f);
+    -> decltype((*_STD::forward<_A0>(__a0)).*__f);

 // bullet 5

 template <class _F, class ..._Args>
 auto
 __invoke(_F&& __f, _Args&& ...__args)
-    -> decltype(_VSTD::forward<_F>(__f)(_VSTD::forward<_Args>(__args)...));
+    -> decltype(_STD::forward<_F>(__f)(_STD::forward<_Args>(__args)...));

 // __invokable

@@ -2935,7 +2964,7 @@ struct __invokable_imp
    : private __check_complete<_F, _Args...>
 {
    typedef decltype(
-            __invoke(_VSTD::declval<_F>(), _VSTD::declval<_Args>()...)
+            __invoke(_STD::declval<_F>(), _STD::declval<_Args>()...)
                    ) type;
    static const bool value = !is_same<type, __nat>::value;
 };
@@ -2970,108 +2999,14 @@ struct __invoke_of

 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
-typename enable_if
-<
-    is_move_constructible<_Tp>::value &&
-    is_move_assignable<_Tp>::value
->::type
-#else
 void
-#endif
-swap(_Tp& __x, _Tp& __y) _NOEXCEPT_(is_nothrow_move_constructible<_Tp>::value &&
-                                    is_nothrow_move_assignable<_Tp>::value)
+swap(_Tp& __x, _Tp& __y)
 {
-    _Tp __t(_VSTD::move(__x));
-    __x = _VSTD::move(__y);
-    __y = _VSTD::move(__t);
+    _Tp __t(_STD::move(__x));
+    __x = _STD::move(__y);
+    __y = _STD::move(__t);
 }

-template <class _ForwardIterator1, class _ForwardIterator2>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b)
-    //                                  _NOEXCEPT_(_NOEXCEPT_(swap(*__a, *__b)))
-               _NOEXCEPT_(_NOEXCEPT_(swap(*_VSTD::declval<_ForwardIterator1>(),
-                                          *_VSTD::declval<_ForwardIterator2>())))
-{
-    swap(*__a, *__b);
-}
-
-// __swappable
-
-namespace __detail
-{
-
-using _VSTD::swap;
-__nat swap(__any, __any);
-
-template <class _Tp>
-struct __swappable
-{
-    typedef decltype(swap(_VSTD::declval<_Tp&>(), _VSTD::declval<_Tp&>())) type;
-    static const bool value = !is_same<type, __nat>::value;
-};
-
-}  // __detail
-
-template <class _Tp>
-struct __is_swappable
-    : public integral_constant<bool, __detail::__swappable<_Tp>::value>
-{
-};
-
-#if __has_feature(cxx_noexcept)
-
-template <bool, class _Tp>
-struct __is_nothrow_swappable_imp
-    : public integral_constant<bool, noexcept(swap(_VSTD::declval<_Tp&>(),
-                                                   _VSTD::declval<_Tp&>()))>
-{
-};
-
-template <class _Tp>
-struct __is_nothrow_swappable_imp<false, _Tp>
-    : public false_type
-{
-};
-
-template <class _Tp>
-struct __is_nothrow_swappable
-    : public __is_nothrow_swappable_imp<__is_swappable<_Tp>::value, _Tp>
-{
-};
-
-#else  // __has_feature(cxx_noexcept)
-
-template <class _Tp>
-struct __is_nothrow_swappable
-    : public false_type
-{
-};
-
-#endif  // __has_feature(cxx_noexcept)
-
-#ifdef _LIBCXX_UNDERLYING_TYPE
-
-template <class _Tp>
-struct underlying_type
-{
-    typedef _LIBCXX_UNDERLYING_TYPE(_Tp) type;
-};
-
-#else  // _LIBCXX_UNDERLYING_TYPE
-
-template <class _Tp, bool _Support = false>
-struct underlying_type
-{
-    static_assert(_Support, "The underyling_type trait requires compiler "
-                            "support. Either no such support exists or "
-                            "libc++ does not know how to use it.");
-};
-
-#endif // _LIBCXX_UNDERLYING_TYPE
-
 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP_TYPE_TRAITS
--- a/include/typeindex
+++ b/include/typeindex
@@ -21,24 +21,24 @@ namespace std
 class type_index
 {
 public:
-    type_index(const type_info& rhs) noexcept;
+    type_index(const type_info& rhs);

-    bool operator==(const type_index& rhs) const noexcept;
-    bool operator!=(const type_index& rhs) const noexcept;
-    bool operator< (const type_index& rhs) const noexcept;
-    bool operator<=(const type_index& rhs) const noexcept;
-    bool operator> (const type_index& rhs) const noexcept;
-    bool operator>=(const type_index& rhs) const noexcept;
+    bool operator==(const type_index& rhs) const;
+    bool operator!=(const type_index& rhs) const;
+    bool operator< (const type_index& rhs) const;
+    bool operator<=(const type_index& rhs) const;
+    bool operator> (const type_index& rhs) const;
+    bool operator>=(const type_index& rhs) const;

-    size_t hash_code() const noexcept;
-    const char* name() const noexcept;
+    size_t hash_code() const;
+    const char* name() const;
 };

 template <>
 struct hash<type_index>
    : public unary_function<type_index, size_t>
 {
-    size_t operator()(type_index index) const noexcept;
+    size_t operator()(type_index index) const;
 };

 }  // std
@@ -58,31 +58,25 @@ class _LIBCPP_VISIBLE type_index
    const type_info* __t_;
 public:
    _LIBCPP_INLINE_VISIBILITY
-    type_index(const type_info& __y) _NOEXCEPT : __t_(&__y) {}
+    type_index(const type_info& __y) : __t_(&__y) {}

    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const type_index& __y) const _NOEXCEPT
-        {return *__t_ == *__y.__t_;}
+    bool operator==(const type_index& __y) const {return *__t_ == *__y.__t_;}
    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const type_index& __y) const _NOEXCEPT
-        {return *__t_ != *__y.__t_;}
+    bool operator!=(const type_index& __y) const {return *__t_ != *__y.__t_;}
    _LIBCPP_INLINE_VISIBILITY
-    bool operator< (const type_index& __y) const _NOEXCEPT
-        {return  __t_->before(*__y.__t_);}
+    bool operator< (const type_index& __y) const {return  __t_->before(*__y.__t_);}
    _LIBCPP_INLINE_VISIBILITY
-    bool operator<=(const type_index& __y) const _NOEXCEPT
-        {return !__y.__t_->before(*__t_);}
+    bool operator<=(const type_index& __y) const {return !__y.__t_->before(*__t_);}
    _LIBCPP_INLINE_VISIBILITY
-    bool operator> (const type_index& __y) const _NOEXCEPT
-        {return  __y.__t_->before(*__t_);}
+    bool operator> (const type_index& __y) const {return  __y.__t_->before(*__t_);}
    _LIBCPP_INLINE_VISIBILITY
-    bool operator>=(const type_index& __y) const _NOEXCEPT
-        {return !__t_->before(*__y.__t_);}
+    bool operator>=(const type_index& __y) const {return !__t_->before(*__y.__t_);}

    _LIBCPP_INLINE_VISIBILITY
-    size_t hash_code() const _NOEXCEPT {return __t_->hash_code();}
+    size_t hash_code() const {return __t_->hash_code();}
    _LIBCPP_INLINE_VISIBILITY
-    const char* name() const _NOEXCEPT {return __t_->name();}
+    const char* name() const {return __t_->name();}
 };

 template <class _Tp> struct _LIBCPP_VISIBLE hash;
@@ -92,8 +86,7 @@ struct _LIBCPP_VISIBLE hash<type_index>
    : public unary_function<type_index, size_t>
 {
    _LIBCPP_INLINE_VISIBILITY
-    size_t operator()(type_index __index) const _NOEXCEPT
-        {return __index.hash_code();}
+    size_t operator()(type_index __index) const {return __index.hash_code();}
 };

 _LIBCPP_END_NAMESPACE_STD
--- a/include/typeinfo
+++ b/include/typeinfo
@@ -22,12 +22,12 @@ class type_info
 public:
    virtual ~type_info();

-    bool operator==(const type_info& rhs) const noexcept;
-    bool operator!=(const type_info& rhs) const noexcept;
+    bool operator==(const type_info& rhs) const;
+    bool operator!=(const type_info& rhs) const;

-    bool before(const type_info& rhs) const noexcept;
-    size_t hash_code() const noexcept;
-    const char* name() const noexcept;
+    bool before(const type_info& rhs) const;
+    size_t hash_code() const throw();
+    const char* name() const;

    type_info(const type_info& rhs) = delete;
    type_info& operator=(const type_info& rhs) = delete;
@@ -37,20 +37,20 @@ class bad_cast
    : public exception
 {
 public:
-    bad_cast() noexcept;
-    bad_cast(const bad_cast&) noexcept;
-    bad_cast& operator=(const bad_cast&) noexcept;
-    virtual const char* what() const noexcept;
+    bad_cast() throw();
+    bad_cast(const bad_cast&) throw();
+    bad_cast& operator=(const bad_cast&) throw();
+    virtual const char* what() const throw();
 };

 class bad_typeid
    : public exception
 {
 public:
-    bad_typeid() noexcept;
-    bad_typeid(const bad_typeid&) noexcept;
-    bad_typeid& operator=(const bad_typeid&) noexcept;
-    virtual const char* what() const noexcept;
+    bad_typeid() throw();
+    bad_typeid(const bad_typeid&) throw();
+    bad_typeid& operator=(const bad_typeid&) throw();
+    virtual const char* what() const throw();
 };

 }  // std
@@ -81,20 +81,20 @@ public:
    virtual ~type_info();

    _LIBCPP_INLINE_VISIBILITY
-    const char* name() const _NOEXCEPT {return __type_name;}
+    const char* name() const {return __type_name;}

    _LIBCPP_INLINE_VISIBILITY
-    bool before(const type_info& __arg) const _NOEXCEPT
+    bool before(const type_info& __arg) const
        {return __type_name < __arg.__type_name;}
    _LIBCPP_INLINE_VISIBILITY
-    size_t hash_code() const _NOEXCEPT
+    size_t hash_code() const throw()
        {return *reinterpret_cast<const size_t*>(&__type_name);}

    _LIBCPP_INLINE_VISIBILITY
-    bool operator==(const type_info& __arg) const _NOEXCEPT
+    bool operator==(const type_info& __arg) const
        {return __type_name == __arg.__type_name;}
    _LIBCPP_INLINE_VISIBILITY
-    bool operator!=(const type_info& __arg) const _NOEXCEPT
+    bool operator!=(const type_info& __arg) const
        {return !operator==(__arg);}

 };
@@ -103,18 +103,18 @@ class _LIBCPP_EXCEPTION_ABI bad_cast
    : public exception
 {
 public:
-    bad_cast() _NOEXCEPT;
-    virtual ~bad_cast() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_cast() throw();
+    virtual ~bad_cast() throw();
+    virtual const char* what() const throw();
 };

 class _LIBCPP_EXCEPTION_ABI bad_typeid
    : public exception
 {
 public:
-    bad_typeid() _NOEXCEPT;
-    virtual ~bad_typeid() _NOEXCEPT;
-    virtual const char* what() const _NOEXCEPT;
+    bad_typeid() throw();
+    virtual ~bad_typeid() throw();
+    virtual const char* what() const throw();
 };

 }  // std
--- a/include/unordered_map
+++ b/include/unordered_map
--- a/include/unordered_set
+++ b/include/unordered_set
@@ -43,12 +43,7 @@ public:
    typedef /unspecified/ local_iterator;
    typedef /unspecified/ const_local_iterator;

-    unordered_set()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit unordered_set(size_type n, const hasher& hf = hasher(),
+    explicit unordered_set(size_type n = 0, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
    template <class InputIterator>
@@ -59,37 +54,28 @@ public:
    explicit unordered_set(const allocator_type&);
    unordered_set(const unordered_set&);
    unordered_set(const unordered_set&, const Allocator&);
-    unordered_set(unordered_set&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
+    unordered_set(unordered_set&&);
    unordered_set(unordered_set&&, const Allocator&);
    unordered_set(initializer_list<value_type>, size_type n = 0,
                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    ~unordered_set();
    unordered_set& operator=(const unordered_set&);
-    unordered_set& operator=(unordered_set&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
+    unordered_set& operator=(unordered_set&&);
    unordered_set& operator=(initializer_list<value_type>);

-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;

-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;

-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+    const_iterator cbegin() const;
+    const_iterator cend()   const;

    template <class... Args>
        pair<iterator, bool> emplace(Args&&... args);
@@ -106,14 +92,9 @@ public:
    iterator erase(const_iterator position);
    size_type erase(const key_type& k);
    iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();

-    void swap(unordered_set&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
+    void swap(unordered_set&);

    hasher hash_function() const;
    key_equal key_eq() const;
@@ -124,8 +105,8 @@ public:
    pair<iterator, iterator>             equal_range(const key_type& k);
    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;

-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;

    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
@@ -137,8 +118,8 @@ public:
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;

-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
+    float load_factor() const;
+    float max_load_factor() const;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
@@ -146,8 +127,7 @@ public:

 template <class Value, class Hash, class Pred, class Alloc>
    void swap(unordered_set<Value, Hash, Pred, Alloc>& x,
-              unordered_set<Value, Hash, Pred, Alloc>& y)
-              noexcept(noexcept(x.swap(y)));
+              unordered_set<Value, Hash, Pred, Alloc>& y);

 template <class Value, class Hash, class Pred, class Alloc>
    bool
@@ -182,12 +162,7 @@ public:
    typedef /unspecified/ local_iterator;
    typedef /unspecified/ const_local_iterator;

-    unordered_multiset()
-        noexcept(
-            is_nothrow_default_constructible<hasher>::value &&
-            is_nothrow_default_constructible<key_equal>::value &&
-            is_nothrow_default_constructible<allocator_type>::value);
-    explicit unordered_multiset(size_type n, const hasher& hf = hasher(),
+    explicit unordered_multiset(size_type n = 0, const hasher& hf = hasher(),
                           const key_equal& eql = key_equal(),
                           const allocator_type& a = allocator_type());
    template <class InputIterator>
@@ -198,37 +173,28 @@ public:
    explicit unordered_multiset(const allocator_type&);
    unordered_multiset(const unordered_multiset&);
    unordered_multiset(const unordered_multiset&, const Allocator&);
-    unordered_multiset(unordered_multiset&&)
-        noexcept(
-            is_nothrow_move_constructible<hasher>::value &&
-            is_nothrow_move_constructible<key_equal>::value &&
-            is_nothrow_move_constructible<allocator_type>::value);
+    unordered_multiset(unordered_multiset&&);
    unordered_multiset(unordered_multiset&&, const Allocator&);
    unordered_multiset(initializer_list<value_type>, size_type n = /see below/,
                  const hasher& hf = hasher(), const key_equal& eql = key_equal(),
                  const allocator_type& a = allocator_type());
    ~unordered_multiset();
    unordered_multiset& operator=(const unordered_multiset&);
-    unordered_multiset& operator=(unordered_multiset&&)
-        noexcept(
-            allocator_type::propagate_on_container_move_assignment::value &&
-            is_nothrow_move_assignable<allocator_type>::value &&
-            is_nothrow_move_assignable<hasher>::value &&
-            is_nothrow_move_assignable<key_equal>::value);
+    unordered_multiset& operator=(unordered_multiset&&);
    unordered_multiset& operator=(initializer_list<value_type>);

-    allocator_type get_allocator() const noexcept;
+    allocator_type get_allocator() const;

-    bool      empty() const noexcept;
-    size_type size() const noexcept;
-    size_type max_size() const noexcept;
+    bool      empty() const;
+    size_type size() const;
+    size_type max_size() const;

-    iterator       begin() noexcept;
-    iterator       end() noexcept;
-    const_iterator begin()  const noexcept;
-    const_iterator end()    const noexcept;
-    const_iterator cbegin() const noexcept;
-    const_iterator cend()   const noexcept;
+    iterator       begin();
+    iterator       end();
+    const_iterator begin()  const;
+    const_iterator end()    const;
+    const_iterator cbegin() const;
+    const_iterator cend()   const;

    template <class... Args>
        iterator emplace(Args&&... args);
@@ -245,14 +211,9 @@ public:
    iterator erase(const_iterator position);
    size_type erase(const key_type& k);
    iterator erase(const_iterator first, const_iterator last);
-    void clear() noexcept;
+    void clear();

-    void swap(unordered_multiset&)
-        noexcept(
-            (!allocator_type::propagate_on_container_swap::value ||
-             __is_nothrow_swappable<allocator_type>::value) &&
-            __is_nothrow_swappable<hasher>::value &&
-            __is_nothrow_swappable<key_equal>::value);
+    void swap(unordered_multiset&);

    hasher hash_function() const;
    key_equal key_eq() const;
@@ -263,8 +224,8 @@ public:
    pair<iterator, iterator>             equal_range(const key_type& k);
    pair<const_iterator, const_iterator> equal_range(const key_type& k) const;

-    size_type bucket_count() const noexcept;
-    size_type max_bucket_count() const noexcept;
+    size_type bucket_count() const;
+    size_type max_bucket_count() const;

    size_type bucket_size(size_type n) const;
    size_type bucket(const key_type& k) const;
@@ -276,8 +237,8 @@ public:
    const_local_iterator cbegin(size_type n) const;
    const_local_iterator cend(size_type n) const;

-    float load_factor() const noexcept;
-    float max_load_factor() const noexcept;
+    float load_factor() const;
+    float max_load_factor() const;
    void max_load_factor(float z);
    void rehash(size_type n);
    void reserve(size_type n);
@@ -285,8 +246,7 @@ public:

 template <class Value, class Hash, class Pred, class Alloc>
    void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x,
-              unordered_multiset<Value, Hash, Pred, Alloc>& y)
-              noexcept(noexcept(x.swap(y)));
+              unordered_multiset<Value, Hash, Pred, Alloc>& y);

 template <class Value, class Hash, class Pred, class Alloc>
    bool
@@ -340,9 +300,7 @@ public:
    typedef typename __table::const_local_iterator const_local_iterator;

    _LIBCPP_INLINE_VISIBILITY
-    unordered_set()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-        {} // = default;
+    unordered_set() {} // = default;
    explicit unordered_set(size_type __n, const hasher& __hf = hasher(),
                           const key_equal& __eql = key_equal());
    unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql,
@@ -361,11 +319,9 @@ public:
    unordered_set(const unordered_set& __u);
    unordered_set(const unordered_set& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_set(unordered_set&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+    unordered_set(unordered_set&& __u);
    unordered_set(unordered_set&& __u, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    unordered_set(initializer_list<value_type> __il);
    unordered_set(initializer_list<value_type> __il, size_type __n,
                  const hasher& __hf = hasher(),
@@ -373,55 +329,46 @@ public:
    unordered_set(initializer_list<value_type> __il, size_type __n,
                  const hasher& __hf, const key_equal& __eql,
                  const allocator_type& __a);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    // ~unordered_set() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_set& operator=(const unordered_set& __u)
-    {
-        __table_ = __u.__table_;
-        return *this;
-    }
+    // unordered_set& operator=(const unordered_set& __u) = default;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_set& operator=(unordered_set&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+    unordered_set& operator=(unordered_set&& __u);
 #endif
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    unordered_set& operator=(initializer_list<value_type> __il);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
+    allocator_type get_allocator() const
        {return allocator_type(__table_.__node_alloc());}

    _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
+    bool      empty() const {return __table_.size() == 0;}
    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
+    size_type size() const  {return __table_.size();}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+    size_type max_size() const {return __table_.max_size();}

    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
+    iterator       begin()        {return __table_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
+    iterator       end()          {return __table_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
+    const_iterator begin()  const {return __table_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
+    const_iterator end()    const {return __table_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
+    const_iterator cbegin() const {return __table_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+    const_iterator cend()   const {return __table_.end();}

 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        pair<iterator, bool> emplace(_Args&&... __args)
-            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);}
+            {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...);}
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        iterator emplace_hint(const_iterator, _Args&&... __args)
-            {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;}
+            {return __table_.__emplace_unique(_STD::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)
@@ -429,7 +376,7 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    pair<iterator, bool> insert(value_type&& __x)
-        {return __table_.__insert_unique(_VSTD::move(__x));}
+        {return __table_.__insert_unique(_STD::move(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator, const value_type& __x)
@@ -437,15 +384,13 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator, value_type&& __x)
-        {return insert(_VSTD::move(__x)).first;}
+        {return insert(_STD::move(__x)).first;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _InputIterator>
        void insert(_InputIterator __first, _InputIterator __last);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    void insert(initializer_list<value_type> __il)
        {insert(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
    iterator erase(const_iterator __p) {return __table_.erase(__p);}
@@ -455,12 +400,10 @@ public:
    iterator erase(const_iterator __first, const_iterator __last)
        {return __table_.erase(__first, __last);}
    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
+    void clear() {__table_.clear();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_set& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
+    void swap(unordered_set& __u) {__table_.swap(__u.__table_);}

    _LIBCPP_INLINE_VISIBILITY
    hasher hash_function() const {return __table_.hash_function();}
@@ -481,9 +424,9 @@ public:
        {return __table_.__equal_range_unique(__k);}

    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
+    size_type bucket_count() const {return __table_.bucket_count();}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}

    _LIBCPP_INLINE_VISIBILITY
    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
@@ -504,9 +447,9 @@ public:
    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}

    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
+    float load_factor() const {return __table_.load_factor();}
    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
+    float max_load_factor() const {return __table_.max_load_factor();}
    _LIBCPP_INLINE_VISIBILITY
    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
    _LIBCPP_INLINE_VISIBILITY
@@ -593,28 +536,25 @@ template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
        unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_VSTD::move(__u.__table_))
+    : __table_(_STD::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_(_VSTD::move(__u.__table_), __a)
+    : __table_(_STD::move(__u.__table_), __a)
 {
    if (__a != __u.get_allocator())
    {
        iterator __i = __u.begin();
        while (__u.size() != 0)
-            __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_));
+            __table_.__insert_unique(_STD::move(__u.__table_.remove(__i++)->__value_));
    }
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
        initializer_list<value_type> __il)
@@ -642,24 +582,19 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(
    insert(__il.begin(), __il.end());
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
 unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
-    __table_ = _VSTD::move(__u.__table_);
+    __table_ = _STD::move(__u.__table_);
    return *this;
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_set<_Value, _Hash, _Pred, _Alloc>&
@@ -670,8 +605,6 @@ unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(
    return *this;
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -688,7 +621,6 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x,
     unordered_set<_Value, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
@@ -752,9 +684,7 @@ public:
    typedef typename __table::const_local_iterator const_local_iterator;

    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset()
-        _NOEXCEPT_(is_nothrow_default_constructible<__table>::value)
-        {} // = default
+    unordered_multiset() {} // = default
    explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(),
                                const key_equal& __eql = key_equal());
    unordered_multiset(size_type __n, const hasher& __hf,
@@ -773,11 +703,9 @@ public:
    unordered_multiset(const unordered_multiset& __u);
    unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_multiset(unordered_multiset&& __u)
-        _NOEXCEPT_(is_nothrow_move_constructible<__table>::value);
+    unordered_multiset(unordered_multiset&& __u);
    unordered_multiset(unordered_multiset&& __u, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    unordered_multiset(initializer_list<value_type> __il);
    unordered_multiset(initializer_list<value_type> __il, size_type __n,
                       const hasher& __hf = hasher(),
@@ -785,61 +713,52 @@ public:
    unordered_multiset(initializer_list<value_type> __il, size_type __n,
                       const hasher& __hf, const key_equal& __eql,
                       const allocator_type& __a);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    // ~unordered_multiset() = default;
-    _LIBCPP_INLINE_VISIBILITY
-    unordered_multiset& operator=(const unordered_multiset& __u)
-    {
-        __table_ = __u.__table_;
-        return *this;
-    }
+    // unordered_multiset& operator=(const unordered_multiset& __u) = default;
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    unordered_multiset& operator=(unordered_multiset&& __u)
-        _NOEXCEPT_(is_nothrow_move_assignable<__table>::value);
+    unordered_multiset& operator=(unordered_multiset&& __u);
 #endif
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    unordered_multiset& operator=(initializer_list<value_type> __il);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
-    allocator_type get_allocator() const _NOEXCEPT
+    allocator_type get_allocator() const
        {return allocator_type(__table_.__node_alloc());}

    _LIBCPP_INLINE_VISIBILITY
-    bool      empty() const _NOEXCEPT {return __table_.size() == 0;}
+    bool      empty() const {return __table_.size() == 0;}
    _LIBCPP_INLINE_VISIBILITY
-    size_type size() const _NOEXCEPT  {return __table_.size();}
+    size_type size() const  {return __table_.size();}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_size() const _NOEXCEPT {return __table_.max_size();}
+    size_type max_size() const {return __table_.max_size();}

    _LIBCPP_INLINE_VISIBILITY
-    iterator       begin() _NOEXCEPT        {return __table_.begin();}
+    iterator       begin()        {return __table_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    iterator       end() _NOEXCEPT          {return __table_.end();}
+    iterator       end()          {return __table_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator begin()  const _NOEXCEPT {return __table_.begin();}
+    const_iterator begin()  const {return __table_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator end()    const _NOEXCEPT {return __table_.end();}
+    const_iterator end()    const {return __table_.end();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cbegin() const _NOEXCEPT {return __table_.begin();}
+    const_iterator cbegin() const {return __table_.begin();}
    _LIBCPP_INLINE_VISIBILITY
-    const_iterator cend()   const _NOEXCEPT {return __table_.end();}
+    const_iterator cend()   const {return __table_.end();}

 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        iterator emplace(_Args&&... __args)
-            {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);}
+            {return __table_.__emplace_multi(_STD::forward<_Args>(__args)...);}
    template <class... _Args>
        _LIBCPP_INLINE_VISIBILITY
        iterator emplace_hint(const_iterator __p, _Args&&... __args)
-            {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);}
+            {return __table_.__emplace_hint_multi(__p, _STD::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(_VSTD::move(__x));}
+    iterator insert(value_type&& __x) {return __table_.__insert_multi(_STD::move(__x));}
 #endif
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator __p, const value_type& __x)
@@ -847,15 +766,13 @@ public:
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    iterator insert(const_iterator __p, value_type&& __x)
-        {return __table_.__insert_multi(__p, _VSTD::move(__x));}
+        {return __table_.__insert_multi(__p, _STD::move(__x));}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    template <class _InputIterator>
        void insert(_InputIterator __first, _InputIterator __last);
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    _LIBCPP_INLINE_VISIBILITY
    void insert(initializer_list<value_type> __il)
        {insert(__il.begin(), __il.end());}
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS

    _LIBCPP_INLINE_VISIBILITY
    iterator erase(const_iterator __p) {return __table_.erase(__p);}
@@ -865,12 +782,10 @@ public:
    iterator erase(const_iterator __first, const_iterator __last)
        {return __table_.erase(__first, __last);}
    _LIBCPP_INLINE_VISIBILITY
-    void clear() _NOEXCEPT {__table_.clear();}
+    void clear() {__table_.clear();}

    _LIBCPP_INLINE_VISIBILITY
-    void swap(unordered_multiset& __u)
-        _NOEXCEPT_(__is_nothrow_swappable<__table>::value)
-        {__table_.swap(__u.__table_);}
+    void swap(unordered_multiset& __u) {__table_.swap(__u.__table_);}

    _LIBCPP_INLINE_VISIBILITY
    hasher hash_function() const {return __table_.hash_function();}
@@ -891,9 +806,9 @@ public:
        {return __table_.__equal_range_multi(__k);}

    _LIBCPP_INLINE_VISIBILITY
-    size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();}
+    size_type bucket_count() const {return __table_.bucket_count();}
    _LIBCPP_INLINE_VISIBILITY
-    size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();}
+    size_type max_bucket_count() const {return __table_.max_bucket_count();}

    _LIBCPP_INLINE_VISIBILITY
    size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);}
@@ -914,9 +829,9 @@ public:
    const_local_iterator cend(size_type __n) const   {return __table_.cend(__n);}

    _LIBCPP_INLINE_VISIBILITY
-    float load_factor() const _NOEXCEPT {return __table_.load_factor();}
+    float load_factor() const {return __table_.load_factor();}
    _LIBCPP_INLINE_VISIBILITY
-    float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();}
+    float max_load_factor() const {return __table_.max_load_factor();}
    _LIBCPP_INLINE_VISIBILITY
    void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);}
    _LIBCPP_INLINE_VISIBILITY
@@ -1004,28 +919,25 @@ template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline _LIBCPP_INLINE_VISIBILITY
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
        unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_constructible<__table>::value)
-    : __table_(_VSTD::move(__u.__table_))
+    : __table_(_STD::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_(_VSTD::move(__u.__table_), __a)
+    : __table_(_STD::move(__u.__table_), __a)
 {
    if (__a != __u.get_allocator())
    {
        iterator __i = __u.begin();
        while (__u.size() != 0)
-            __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_));
+            __table_.__insert_multi(_STD::move(__u.__table_.remove(__i++)->__value_));
    }
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
        initializer_list<value_type> __il)
@@ -1053,8 +965,6 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset(
    insert(__il.begin(), __il.end());
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

 template <class _Value, class _Hash, class _Pred, class _Alloc>
@@ -1062,16 +972,13 @@ inline _LIBCPP_INLINE_VISIBILITY
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
        unordered_multiset&& __u)
-    _NOEXCEPT_(is_nothrow_move_assignable<__table>::value)
 {
-    __table_ = _VSTD::move(__u.__table_);
+    __table_ = _STD::move(__u.__table_);
    return *this;
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 inline
 unordered_multiset<_Value, _Hash, _Pred, _Alloc>&
@@ -1082,8 +989,6 @@ unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=(
    return *this;
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Value, class _Hash, class _Pred, class _Alloc>
 template <class _InputIterator>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1100,7 +1005,6 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 swap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
     unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y)
-    _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y)))
 {
    __x.swap(__y);
 }
@@ -1119,9 +1023,9 @@ operator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x,
    {
        _EqRng __xeq = __x.equal_range(*__i);
        _EqRng __yeq = __y.equal_range(*__i);
-        if (_VSTD::distance(__xeq.first, __xeq.second) !=
-            _VSTD::distance(__yeq.first, __yeq.second) ||
-                  !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
+        if (_STD::distance(__xeq.first, __xeq.second) !=
+            _STD::distance(__yeq.first, __yeq.second) ||
+                  !_STD::is_permutation(__xeq.first, __xeq.second, __yeq.first))
            return false;
        __i = __xeq.second;
    }
--- a/include/utility
+++ b/include/utility
@@ -29,19 +29,11 @@ namespace rel_ops
    template<class T> bool operator>=(const T&, const T&);
 }

-template<class T>
-void
-swap(T& a, T& b) noexcept(is_nothrow_move_constructible<T>::value &&
-                          is_nothrow_move_assignable<T>::value);
+template<class T> void swap(T& a, T& b);
+template <class T, size_t N> void swap(T (&a)[N], T (&b)[N]);

-template <class T, size_t N>
-void
-swap(T (&a)[N], T (&b)[N]) noexcept(noexcept(swap(*a, *b)));
-
-template <class T> T&& forward(typename remove_reference<T>::type& t) noexcept;
-template <class T> T&& forward(typename remove_reference<T>::type&& t) noexcept;
-
-template <class T> typename remove_reference<T>::type&& move(T&&) noexcept;
+template <class T, class U> T&& forward(U&&);
+template <class T> typename remove_reference<T>::type&& move(T&&);

 template <class T>
    typename conditional
@@ -50,7 +42,7 @@ template <class T>
        const T&,
        T&&
    >::type
-    move_if_noexcept(T& x) noexcept;
+    move_if_noexcept(T& x);

 template <class T> typename add_rvalue_reference<T>::type declval() noexcept;

@@ -64,7 +56,6 @@ struct pair
    T2 second;

    pair(const pair&) = default;
-    pair(pair&&) = default;
    constexpr pair();
    pair(const T1& x, const T2& y);
    template <class U, class V> pair(U&& x, V&& y);
@@ -75,12 +66,10 @@ struct pair
             tuple<Args2...> second_args);

    template <class U, class V> pair& operator=(const pair<U, V>& p);
-    pair& operator=(pair&& p) noexcept(is_nothrow_move_assignable<T1>::value &&
-                                       is_nothrow_move_assignable<T2>::value);
+    pair& operator=(pair&& p);
    template <class U, class V> pair& operator=(pair<U, V>&& p);

-    void swap(pair& p) noexcept(noexcept(swap(first, p.first)) &&
-                                noexcept(swap(second, p.second)));
+    void swap(pair& p);
 };

 template <class T1, class T2> bool operator==(const pair<T1,T2>&, const pair<T1,T2>&);
@@ -91,9 +80,7 @@ template <class T1, class T2> bool operator>=(const pair<T1,T2>&, const pair<T1,
 template <class T1, class T2> bool operator<=(const pair<T1,T2>&, const pair<T1,T2>&);

 template <class T1, class T2> pair<V1, V2> make_pair(T1&&, T2&&);
-template <class T1, class T2>
-void
-swap(pair<T1, T2>& x, pair<T1, T2>& y) noexcept(noexcept(x.swap(y)));
+template <class T1, class T2> void swap(pair<T1, T2>& x, pair<T1, T2>& y);

 struct piecewise_construct_t { };
 constexpr piecewise_construct_t piecewise_construct = piecewise_construct_t();
@@ -107,15 +94,15 @@ template <class T1, class T2> struct tuple_element<1, std::pair<T1, T2> >;

 template<size_t I, class T1, class T2>
    typename tuple_element<I, std::pair<T1, T2> >::type&
-    get(std::pair<T1, T2>&) noexcept;
+    get(std::pair<T1, T2>&);

 template<size_t I, class T1, class T2>
    const typename const tuple_element<I, std::pair<T1, T2> >::type&
-    get(const std::pair<T1, T2>&) noexcept;
+    get(const std::pair<T1, T2>&);

 template<size_t I, class T1, class T2>
    typename tuple_element<I, std::pair<T1, T2> >::type&&
-    get(std::pair<T1, T2>&&) noexcept;
+    get(std::pair<T1, T2>&&);

 }  // std

@@ -181,9 +168,9 @@ swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, _ForwardItera
 template<class _Tp, size_t _N>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-swap(_Tp (&__a)[_N], _Tp (&__b)[_N]) _NOEXCEPT_(__is_nothrow_swappable<_Tp>::value)
+swap(_Tp (&__a)[_N], _Tp (&__b)[_N])
 {
-    _VSTD::swap_ranges(__a, __a + _N, __b);
+    _STD::swap_ranges(__a, __a + _N, __b);
 }

 template <class _Tp>
@@ -198,15 +185,18 @@ typename conditional
 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 const _Tp&
 #endif
-move_if_noexcept(_Tp& __x) _NOEXCEPT
+move_if_noexcept(_Tp& __x)
 {
-    return _VSTD::move(__x);
+    return _STD::move(__x);
 }

 struct _LIBCPP_VISIBLE piecewise_construct_t { };
 //constexpr
 extern const piecewise_construct_t piecewise_construct;// = piecewise_construct_t();

+template <class _T1, class _T2> struct pair;
+template <class _T1, class _T2> void swap(pair<_T1, _T2>&, pair<_T1, _T2>&);
+
 template <class _T1, class _T2>
 struct _LIBCPP_VISIBLE pair
 {
@@ -216,9 +206,6 @@ struct _LIBCPP_VISIBLE pair
    _T1 first;
    _T2 second;

-    // pair(const pair&) = default;
-    // pair(pair&&) = default;
-
    _LIBCPP_INLINE_VISIBILITY pair() : first(), second() {}

    _LIBCPP_INLINE_VISIBILITY pair(const _T1& __x, const _T2& __y)
@@ -226,69 +213,29 @@ struct _LIBCPP_VISIBLE pair

    template<class _U1, class _U2>
        _LIBCPP_INLINE_VISIBILITY
-        pair(const pair<_U1, _U2>& __p
-#ifndef _LIBCPP_HAS_NO_ADVANCED_SFINAE
-                 ,typename enable_if<is_constructible<_T1, _U1>::value &&
-                                    is_constructible<_T2, _U2>::value>::type* = 0
-#endif
-                                      )
+        pair(const pair<_U1, _U2>& __p,
+                 typename enable_if<is_convertible<_U1, _T1>::value &&
+                                    is_convertible<_U2, _T2>::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;
-        return *this;
-    }
-
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

    template <class _U1, class _U2,
-              class = typename enable_if<is_constructible<first_type, _U1 >::value &&
-                                         is_constructible<second_type, _U2>::value>::type>
+              class = typename enable_if<is_convertible<_U1, first_type >::value &&
+                                         is_convertible<_U2, second_type>::value>::type>
        _LIBCPP_INLINE_VISIBILITY
        pair(_U1&& __u1, _U2&& __u2)
-            : first(_VSTD::forward<_U1>(__u1)),
-              second(_VSTD::forward<_U2>(__u2))
+            : first(_STD::forward<_U1>(__u1)),
+              second(_STD::forward<_U2>(__u2))
            {}

    template<class _U1, class _U2>
        _LIBCPP_INLINE_VISIBILITY
        pair(pair<_U1, _U2>&& __p,
-                 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 = _VSTD::forward<first_type>(__p.first);
-        second = _VSTD::forward<second_type>(__p.second);
-        return *this;
-    }
+                 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)) {}

 #ifndef _LIBCPP_HAS_NO_VARIADICS

@@ -296,9 +243,9 @@ struct _LIBCPP_VISIBLE pair
             class = typename enable_if<__tuple_convertible<_Tuple, pair>::value>::type>
        _LIBCPP_INLINE_VISIBILITY
        pair(_Tuple&& __p)
-            : first(_VSTD::forward<typename tuple_element<0,
+            : first(_STD::forward<typename tuple_element<0,
                                  typename __make_tuple_types<_Tuple>::type>::type>(get<0>(__p))),
-              second(_VSTD::forward<typename tuple_element<1,
+              second(_STD::forward<typename tuple_element<1,
                                   typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
            {}

@@ -322,22 +269,15 @@ 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  = _VSTD::forward<_U0>(_VSTD::get<0>(__p));
-            second = _VSTD::forward<_U1>(_VSTD::get<1>(__p));
+            first  = _STD::forward<_U0>(_STD::get<0>(__p));
+            second = _STD::forward<_U1>(_STD::get<1>(__p));
            return *this;
        }

 #endif  // _LIBCPP_HAS_NO_VARIADICS

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    void
-    swap(pair& __p) _NOEXCEPT_(__is_nothrow_swappable<first_type>::value &&
-                               __is_nothrow_swappable<second_type>::value)
-    {
-        _VSTD::iter_swap(&first, &__p.first);
-        _VSTD::iter_swap(&second, &__p.second);
-    }
+    void _LIBCPP_INLINE_VISIBILITY swap(pair& __p) {_STD::swap(*this, __p);}
 private:

 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -399,17 +339,11 @@ operator<=(const pair<_T1,_T2>& __x, const pair<_T1,_T2>& __y)

 template <class _T1, class _T2>
 inline _LIBCPP_INLINE_VISIBILITY
-typename enable_if
-<
-    __is_swappable<_T1>::value &&
-    __is_swappable<_T2>::value,
-    void
->::type
+void
 swap(pair<_T1, _T2>& __x, pair<_T1, _T2>& __y)
-                     _NOEXCEPT_((__is_nothrow_swappable<_T1>::value &&
-                                 __is_nothrow_swappable<_T2>::value))
 {
-    __x.swap(__y);
+    swap(__x.first, __y.first);
+    swap(__x.second, __y.second);
 }

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -440,7 +374,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>
-               (_VSTD::forward<_T1>(__t1), _VSTD::forward<_T2>(__t2));
+               (_STD::forward<_T1>(__t1), _STD::forward<_T2>(__t2));
 }

 #else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
@@ -502,13 +436,13 @@ struct __get_pair<0>
    static
    _LIBCPP_INLINE_VISIBILITY
    _T1&
-    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+    get(pair<_T1, _T2>& __p) {return __p.first;}

    template <class _T1, class _T2>
    static
    _LIBCPP_INLINE_VISIBILITY
    const _T1&
-    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.first;}
+    get(const pair<_T1, _T2>& __p) {return __p.first;}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

@@ -516,7 +450,7 @@ struct __get_pair<0>
    static
    _LIBCPP_INLINE_VISIBILITY
    _T1&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T1>(__p.first);}
+    get(pair<_T1, _T2>&& __p) {return _STD::forward<_T1>(__p.first);}

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
@@ -528,13 +462,13 @@ struct __get_pair<1>
    static
    _LIBCPP_INLINE_VISIBILITY
    _T2&
-    get(pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+    get(pair<_T1, _T2>& __p) {return __p.second;}

    template <class _T1, class _T2>
    static
    _LIBCPP_INLINE_VISIBILITY
    const _T2&
-    get(const pair<_T1, _T2>& __p) _NOEXCEPT {return __p.second;}
+    get(const pair<_T1, _T2>& __p) {return __p.second;}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES

@@ -542,7 +476,7 @@ struct __get_pair<1>
    static
    _LIBCPP_INLINE_VISIBILITY
    _T2&&
-    get(pair<_T1, _T2>&& __p) _NOEXCEPT {return _VSTD::forward<_T2>(__p.second);}
+    get(pair<_T1, _T2>&& __p) {return _STD::forward<_T2>(__p.second);}

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };
@@ -550,7 +484,7 @@ struct __get_pair<1>
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY inline
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(pair<_T1, _T2>& __p) _NOEXCEPT
+get(pair<_T1, _T2>& __p)
 {
    return __get_pair<_Ip>::get(__p);
 }
@@ -558,7 +492,7 @@ get(pair<_T1, _T2>& __p) _NOEXCEPT
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY inline
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
-get(const pair<_T1, _T2>& __p) _NOEXCEPT
+get(const pair<_T1, _T2>& __p)
 {
    return __get_pair<_Ip>::get(__p);
 }
@@ -568,9 +502,9 @@ get(const pair<_T1, _T2>& __p) _NOEXCEPT
 template <size_t _Ip, class _T1, class _T2>
 _LIBCPP_INLINE_VISIBILITY inline
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&&
-get(pair<_T1, _T2>&& __p) _NOEXCEPT
+get(pair<_T1, _T2>&& __p)
 {
-    return __get_pair<_Ip>::get(_VSTD::move(__p));
+    return __get_pair<_Ip>::get(_STD::move(__p));
 }

 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
--- a/include/valarray
+++ b/include/valarray
@@ -798,10 +798,8 @@ public:
    valarray(const valarray& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    valarray(valarray&& __v);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    valarray(initializer_list<value_type> __il);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    valarray(const slice_array<value_type>& __sa);
    valarray(const gslice_array<value_type>& __ga);
    valarray(const mask_array<value_type>& __ma);
@@ -812,17 +810,13 @@ public:
    valarray& operator=(const valarray& __v);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    valarray& operator=(valarray&& __v);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
    valarray& operator=(initializer_list<value_type>);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    valarray& operator=(const value_type& __x);
    valarray& operator=(const slice_array<value_type>& __sa);
    valarray& operator=(const gslice_array<value_type>& __ga);
    valarray& operator=(const mask_array<value_type>& __ma);
    valarray& operator=(const indirect_array<value_type>& __ia);
-    template <class _ValExpr>
-        valarray& operator=(const __val_expr<_ValExpr>& __v);

    // element access:
    _LIBCPP_INLINE_VISIBILITY
@@ -2712,10 +2706,6 @@ valarray<_Tp>::valarray(valarray&& __v)
    __v.__begin_ = __v.__end_ = nullptr;
 }

-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp>
 valarray<_Tp>::valarray(initializer_list<value_type> __il)
    : __begin_(0),
@@ -2742,7 +2732,7 @@ valarray<_Tp>::valarray(initializer_list<value_type> __il)
    }
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 template <class _Tp>
 valarray<_Tp>::valarray(const slice_array<value_type>& __sa)
@@ -2872,7 +2862,7 @@ valarray<_Tp>::operator=(const valarray& __v)
    {
        if (size() != __v.size())
            resize(__v.size());
-        _VSTD::copy(__v.__begin_, __v.__end_, __begin_);
+        _STD::copy(__v.__begin_, __v.__end_, __begin_);
    }
    return *this;
 }
@@ -2892,10 +2882,6 @@ valarray<_Tp>::operator=(valarray&& __v)
    return *this;
 }

-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
-
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 valarray<_Tp>&
@@ -2903,18 +2889,18 @@ valarray<_Tp>::operator=(initializer_list<value_type> __il)
 {
    if (size() != __il.size())
        resize(__il.size());
-    _VSTD::copy(__il.begin(), __il.end(), __begin_);
+    _STD::copy(__il.begin(), __il.end(), __begin_);
    return *this;
 }

-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 valarray<_Tp>&
 valarray<_Tp>::operator=(const value_type& __x)
 {
-    _VSTD::fill(__begin_, __end_, __x);
+    _STD::fill(__begin_, __end_, __x);
    return *this;
 }

@@ -2972,21 +2958,6 @@ valarray<_Tp>::operator=(const indirect_array<value_type>& __ia)
    return *this;
 }

-template <class _Tp>
-template <class _ValExpr>
-inline _LIBCPP_INLINE_VISIBILITY
-valarray<_Tp>&
-valarray<_Tp>::operator=(const __val_expr<_ValExpr>& __v)
-{
-    size_t __n = __v.size();
-    if (size() != __n)
-        resize(__n);
-    value_type* __t = __begin_;
-    for (size_t __i = 0; __i != __n; ++__t, ++__i)
-        *__t = result_type(__v[__i]);
-    return *this;
-}
-
 template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 __val_expr<__slice_expr<const valarray<_Tp>&> >
@@ -3444,8 +3415,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 void
 valarray<_Tp>::swap(valarray& __v)
 {
-    _VSTD::swap(__begin_, __v.__begin_);
-    _VSTD::swap(__end_, __v.__end_);
+    _STD::swap(__begin_, __v.__begin_);
+    _STD::swap(__end_, __v.__end_);
 }

 template <class _Tp>
@@ -3469,7 +3440,7 @@ valarray<_Tp>::min() const
 {
    if (__begin_ == __end_)
        return value_type();
-    return *_VSTD::min_element(__begin_, __end_);
+    return *_STD::min_element(__begin_, __end_);
 }

 template <class _Tp>
@@ -3479,7 +3450,7 @@ valarray<_Tp>::max() const
 {
    if (__begin_ == __end_)
        return value_type();
-    return *_VSTD::max_element(__begin_, __end_);
+    return *_STD::max_element(__begin_, __end_);
 }

 template <class _Tp>
@@ -3498,14 +3469,14 @@ valarray<_Tp>::shift(int __i) const
        value_type* __te;
        if (__i >= 0)
        {
-            __i = _VSTD::min(__i, static_cast<int>(__n));
+            __i = _STD::min(__i, static_cast<int>(__n));
            __sb = __begin_ + __i;
            __tb = __r.__begin_;
            __te = __r.__begin_ + (__n - __i);
        }
        else
        {
-            __i = _VSTD::min(-__i, static_cast<int>(__n));
+            __i = _STD::min(-__i, static_cast<int>(__n));
            __sb = __begin_;
            __tb = __r.__begin_ + __i;
            __te = __r.__begin_ + __n;
--- a/include/vector
+++ b/include/vector
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,17 +1,9 @@
 # Get sources
-file(GLOB sources ../src/*.cpp)
-if(WIN32)
-  file(GLOB win32_sources ../src/support/win32/*.cpp)
-  list(APPEND sources ${win32_sources})
-endif()
+file(GLOB_RECURSE sources ../src/*.cpp)

 # Add all the headers to the project for IDEs.
 if (MSVC_IDE OR XCODE)
  file(GLOB_RECURSE headers ../include/*)
-  if(WIN32)
-    file( GLOB win32_headers ../include/support/win32/*.h)
-    list(APPEND headers ${win32_headers})
-  endif()
  # Force them all into the headers dir on MSVC, otherwise they end up at
  # project scope because they don't have extensions.
  if (MSVC_IDE)
--- a/lib/buildit
+++ b/lib/buildit
@@ -26,7 +26,7 @@ if [ -z $MACOSX_DEPLOYMENT_TARGET ]
 then
 	if [ -z $IPHONEOS_DEPLOYMENT_TARGET ]
 	then
-		MACOSX_DEPLOYMENT_TARGET=10.7
+		MACOSX_DEPLOYMENT_TARGET=10.6
 	fi
 fi

@@ -35,8 +35,6 @@ then
  RC_ProjectSourceVersion=1
 fi

-EXTRA_FLAGS="-std=c++0x"
-
 case $TRIPLE in
  *-apple-*)
    if [ -z $RC_XBS ]
@@ -55,6 +53,7 @@ case $TRIPLE in
 			-Wl,-unexported_symbols_list,libc++unexp.exp  \
 			/usr/lib/libSystem.B.dylib"
 	else
+		EXTRA_FLAGS="-std=c++0x "
 		RE_EXPORT_LINE="/usr/lib/libc++abi.dylib -Wl,-reexported_symbols_list,libc++abi.exp"
 		if [ -n "$SDKROOT" ]
 		then
@@ -70,29 +69,20 @@ case $TRIPLE in
 		fi
 	    LDSHARED_FLAGS="-o libc++.1.dylib \
 			-dynamiclib -nodefaultlibs  \
-			-current_version ${RC_ProjectSourceVersion} \
-			-compatibility_version 1 \
+			-current_version ${RC_ProjectSourceVersion} -compatibility_version 1 \
 			-install_name /usr/lib/libc++.1.dylib \
 			-lSystem  \
 			-Wl,-unexported_symbols_list,libc++unexp.exp  \
 			${RE_EXPORT_LINE}  \
-			-Wl,-force_symbols_not_weak_list,notweak.exp \
-			-Wl,-force_symbols_weak_list,weak.exp"
+			-Wl,-force_symbols_not_weak_list,notweak.exp "
 	fi
    ;;
-  *-*-mingw*)
-    # FIXME: removing libgcc and libsupc++ dependencies means porting libcxxrt and LLVM/compiler-rt
-    SOEXT=dll
-    LDSHARED_FLAGS="-o libc++.dll \
-        -shared -nodefaultlibs -Wl,--export-all-symbols -Wl,--allow-multiple-definition -Wl,--out-implib,libc++.dll.a \
-        -lsupc++ -lpthread -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcr100 -ladvapi32 -lshell32 -luser32 -lkernel32 -lmingw32 -lgcc_s -lgcc -lmoldname -lmingwex -lmsvcrt"
-	;;
  *)
    RC_CFLAGS="-fPIC"
    SOEXT=so
    LDSHARED_FLAGS="-o libc++.so.1.0 \
        -shared -nodefaultlibs -Wl,-soname,libc++.so.1 \
-        -lpthread -lrt -lc -lstdc++"
+        -lpthread -lrt -lc"
    ;;
 esac

@@ -106,13 +96,8 @@ set -x
 for FILE in ../src/*.cpp; do
 	$CXX -c -g -Os $RC_CFLAGS $EXTRA_FLAGS -nostdinc++ -I../include $FILE
 done
-case $TRIPLE in
-  *-*-mingw*)
-  for FILE in ../src/support/win32/*.cpp; do
-    $CXX -c -g -Os $RC_CFLAGS $EXTRA_FLAGS -nostdinc++ -I../include $FILE
-  done
-  ;;
-esac
+
+
 $CC *.o $RC_CFLAGS $LDSHARED_FLAGS $EXTRA_FLAGS

 #libtool -static -o libc++.a *.o
--- a/lib/weak.exp
+++ b/lib/weak.exp
@@ -1,16 +0,0 @@
-__ZTISt10bad_typeid
-__ZTISt11logic_error
-__ZTISt11range_error
-__ZTISt12domain_error
-__ZTISt12length_error
-__ZTISt12out_of_range
-__ZTISt13bad_exception
-__ZTISt13runtime_error
-__ZTISt14overflow_error
-__ZTISt15underflow_error
-__ZTISt16invalid_argument
-__ZTISt16nested_exception
-__ZTISt20bad_array_new_length
-__ZTISt8bad_cast
-__ZTISt9bad_alloc
-__ZTISt9exception
--- a/src/chrono.cpp
+++ b/src/chrono.cpp
@@ -25,7 +25,7 @@ namespace chrono
 // system_clock

 system_clock::time_point
-system_clock::now() _NOEXCEPT
+system_clock::now()
 {
    timeval tv;
    gettimeofday(&tv, 0);
@@ -33,13 +33,13 @@ system_clock::now() _NOEXCEPT
 }

 time_t
-system_clock::to_time_t(const time_point& t) _NOEXCEPT
+system_clock::to_time_t(const time_point& t)
 {
    return time_t(duration_cast<seconds>(t.time_since_epoch()).count());
 }

 system_clock::time_point
-system_clock::from_time_t(time_t t) _NOEXCEPT
+system_clock::from_time_t(time_t t)
 {
    return system_clock::time_point(seconds(t));
 }
@@ -97,7 +97,7 @@ init_steady_clock()
 #pragma GCC visibility pop

 steady_clock::time_point
-steady_clock::now() _NOEXCEPT
+steady_clock::now()
 {
    static FP fp = init_steady_clock();
    return time_point(duration(fp()));
@@ -114,7 +114,7 @@ steady_clock::now() _NOEXCEPT
 //  instead.

 steady_clock::time_point
-steady_clock::now() _NOEXCEPT
+steady_clock::now()
 {
    struct timespec tp;
    if (0 != clock_gettime(CLOCK_MONOTONIC, &tp))
--- a/src/debug.cpp
+++ b/src/debug.cpp
@@ -1,484 +0,0 @@
-//===-------------------------- debug.cpp ---------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#define _LIBCPP_DEBUG2 1
-#include "__config"
-#include "__debug"
-#include "functional"
-#include "algorithm"
-#include "__hash_table"
-#include "mutex"
-
-_LIBCPP_BEGIN_NAMESPACE_STD
-
-_LIBCPP_VISIBLE
-__libcpp_db*
-__get_db()
-{
-    static __libcpp_db db;
-    return &db;
-};
-
-_LIBCPP_VISIBLE
-const __libcpp_db*
-__get_const_db()
-{
-    return __get_db();
-}
-
-namespace
-{
-
-typedef mutex mutex_type;
-typedef lock_guard<mutex_type> WLock;
-typedef lock_guard<mutex_type> RLock;
-
-mutex_type&
-mut()
-{
-    static mutex_type m;
-    return m;
-}
-
-}  // unnamed namespace
-
-__i_node::~__i_node()
-{
-    if (__next_)
-    {
-        __next_->~__i_node();
-        free(__next_);
-    }
-}
-
-__c_node::~__c_node()
-{
-    free(beg_);
-    if (__next_)
-    {
-        __next_->~__c_node();
-        free(__next_);
-    }
-}
-
-__libcpp_db::__libcpp_db()
-    : __cbeg_(nullptr),
-      __cend_(nullptr),
-      __csz_(0),
-      __ibeg_(nullptr),
-      __iend_(nullptr),
-      __isz_(0)
-{
-}
-
-__libcpp_db::~__libcpp_db()
-{
-    if (__cbeg_)
-    {
-        for (__c_node** p = __cbeg_; p != __cend_; ++p)
-        {
-            if (*p != nullptr)
-            {
-                (*p)->~__c_node();
-                free(*p);
-            }
-        }
-        free(__cbeg_);
-    }
-    if (__ibeg_)
-    {
-        for (__i_node** p = __ibeg_; p != __iend_; ++p)
-        {
-            if (*p != nullptr)
-            {
-                (*p)->~__i_node();
-                free(*p);
-            }
-        }
-        free(__ibeg_);
-    }
-}
-
-void*
-__libcpp_db::__find_c_from_i(void* __i) const
-{
-    RLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    _LIBCPP_ASSERT(i != nullptr, "iterator constructed in translation unit with debug mode not enabled."
-                   "  #define _LIBCPP_DEBUG2 1 for that translation unit.");
-    return i->__c_ != nullptr ? i->__c_->__c_ : nullptr;
-}
-
-void
-__libcpp_db::__insert_ic(void* __i, const void* __c)
-{
-    WLock _(mut());
-    __i_node* i = __insert_iterator(__i);
-    const char* errmsg =
-        "Container constructed in a translation unit with debug mode disabled."
-        " But it is being used in a translation unit with debug mode enabled."
-        " Enable it in the other translation unit with #define _LIBCPP_DEBUG2 1";
-    _LIBCPP_ASSERT(__cbeg_ != __cend_, errmsg);
-    size_t hc = hash<const void*>()(__c) % (__cend_ - __cbeg_);
-    __c_node* c = __cbeg_[hc];
-    _LIBCPP_ASSERT(c != nullptr, errmsg);
-    while (c->__c_ != __c)
-    {
-        c = c->__next_;
-        _LIBCPP_ASSERT(c != nullptr, errmsg);
-    }
-    c->__add(i);
-    i->__c_ = c;
-}
-
-__c_node*
-__libcpp_db::__insert_c(void* __c)
-{
-    WLock _(mut());
-    if (__csz_ + 1 > __cend_ - __cbeg_)
-    {
-        size_t nc = __next_prime(2*(__cend_ - __cbeg_) + 1);
-        __c_node** cbeg = (__c_node**)calloc(nc, sizeof(void*));
-        if (cbeg == nullptr)
-            throw bad_alloc();
-        for (__c_node** p = __cbeg_; p != __cend_; ++p)
-        {
-            __c_node* q = *p;
-            while (q != nullptr)
-            {
-                size_t h = hash<void*>()(q->__c_) % nc;
-                __c_node* r = q->__next_;
-                q->__next_ = cbeg[h];
-                cbeg[h] = q;
-                q = r;
-            }
-        }
-        free(__cbeg_);
-        __cbeg_ = cbeg;
-        __cend_ = __cbeg_ + nc;
-    }
-    size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    __c_node* r = __cbeg_[hc] = (__c_node*)malloc(sizeof(__c_node));
-    if (__cbeg_[hc] == nullptr)
-        throw bad_alloc();
-    r->__c_ = __c;
-    r->__next_ = p;
-    ++__csz_;
-    return r;
-}
-
-void
-__libcpp_db::__erase_i(void* __i)
-{
-    WLock _(mut());
-    if (__ibeg_ != __iend_)
-    {
-        size_t hi = hash<void*>()(__i) % (__iend_ - __ibeg_);
-        __i_node* p = __ibeg_[hi];
-        if (p != nullptr)
-        {
-            __i_node* q = nullptr;
-            while (p->__i_ != __i)
-            {
-                q = p;
-                p = p->__next_;
-                if (p == nullptr)
-                    return;
-            }
-            if (q == nullptr)
-                __ibeg_[hi] = p->__next_;
-            else
-                q->__next_ = p->__next_;
-            __c_node* c = p->__c_;
-            free(p);
-            --__isz_;
-            if (c != nullptr)
-                c->__remove(p);
-        }
-    }
-}
-
-void
-__libcpp_db::__invalidate_all(void* __c)
-{
-    WLock _(mut());
-    size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __invalidate_all A");
-    while (p->__c_ != __c)
-    {
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __invalidate_all B");
-    }
-    while (p->end_ != p->beg_)
-    {
-        --p->end_;
-        (*p->end_)->__c_ = nullptr;
-    }
-}
-
-__c_node*
-__libcpp_db::__find_c_and_lock(void* __c) const
-{
-    mut().lock();
-    size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock A");
-    while (p->__c_ != __c)
-    {
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c_and_lock B");
-    }
-    return p;
-}
-
-__c_node*
-__libcpp_db::__find_c(void* __c) const
-{
-    size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c A");
-    while (p->__c_ != __c)
-    {
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __find_c B");
-    }
-    return p;
-}
-
-void
-__libcpp_db::unlock() const
-{
-    mut().unlock();
-}
-
-void
-__libcpp_db::__erase_c(void* __c)
-{
-    WLock _(mut());
-    size_t hc = hash<void*>()(__c) % (__cend_ - __cbeg_);
-    __c_node* p = __cbeg_[hc];
-    __c_node* q = nullptr;
-    _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c A");
-    while (p->__c_ != __c)
-    {
-        q = p;
-        p = p->__next_;
-        _LIBCPP_ASSERT(p != nullptr, "debug mode internal logic error __erase_c B");
-    }
-    if (q == nullptr)
-        __cbeg_[hc] = p->__next_;
-    else
-        q->__next_ = p->__next_;
-    while (p->end_ != p->beg_)
-    {
-        --p->end_;
-        (*p->end_)->__c_ = nullptr;
-    }
-    free(p->beg_);
-    free(p);
-    --__csz_;
-}
-
-void
-__libcpp_db::__iterator_copy(void* __i, const void* __i0)
-{
-    WLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    __i_node* i0 = __find_iterator(__i0);
-    __c_node* c0 = i0 != nullptr ? i0->__c_ : nullptr;
-    if (i == nullptr && c0 != nullptr)
-        i = __insert_iterator(__i);
-    __c_node* c = i != nullptr ? i->__c_ : nullptr;
-    if (c != c0)
-    {
-        if (c != nullptr)
-            c->__remove(i);
-        if (i != nullptr)
-        {
-            i->__c_ = nullptr;
-            if (c0 != nullptr)
-            {
-                i->__c_ = c0;
-                i->__c_->__add(i);
-            }
-        }
-    }
-}
-
-bool
-__libcpp_db::__dereferenceable(const void* __i) const
-{
-    RLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__dereferenceable(__i);
-}
-
-bool
-__libcpp_db::__decrementable(const void* __i) const
-{
-    RLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__decrementable(__i);
-}
-
-bool
-__libcpp_db::__addable(const void* __i, ptrdiff_t __n) const
-{
-    RLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__addable(__i, __n);
-}
-
-bool
-__libcpp_db::__subscriptable(const void* __i, ptrdiff_t __n) const
-{
-    RLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    return i != nullptr && i->__c_ != nullptr && i->__c_->__subscriptable(__i, __n);
-}
-
-bool
-__libcpp_db::__comparable(const void* __i, const void* __j) const
-{
-    RLock _(mut());
-    __i_node* i = __find_iterator(__i);
-    __i_node* j = __find_iterator(__j);
-    __c_node* ci = i != nullptr ? i->__c_ : nullptr;
-    __c_node* cj = j != nullptr ? j->__c_ : nullptr;
-    return ci != nullptr && ci == cj;
-}
-
-void
-__libcpp_db::swap(void* c1, void* c2)
-{
-    WLock _(mut());
-    size_t hc = hash<void*>()(c1) % (__cend_ - __cbeg_);
-    __c_node* p1 = __cbeg_[hc];
-    _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap A");
-    while (p1->__c_ != c1)
-    {
-        p1 = p1->__next_;
-        _LIBCPP_ASSERT(p1 != nullptr, "debug mode internal logic error swap B");
-    }
-    hc = hash<void*>()(c2) % (__cend_ - __cbeg_);
-    __c_node* p2 = __cbeg_[hc];
-    _LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap C");
-    while (p2->__c_ != c2)
-    {
-        p2 = p2->__next_;
-        _LIBCPP_ASSERT(p2 != nullptr, "debug mode internal logic error swap D");
-    }
-    std::swap(p1->beg_, p2->beg_);
-    std::swap(p1->end_, p2->end_);
-    std::swap(p1->cap_, p2->cap_);
-    for (__i_node** p = p1->beg_; p != p1->end_; ++p)
-        (*p)->__c_ = p1;
-    for (__i_node** p = p2->beg_; p != p2->end_; ++p)
-        (*p)->__c_ = p2;
-}
-
-void
-__libcpp_db::__insert_i(void* __i)
-{
-    WLock _(mut());
-    __insert_iterator(__i);
-}
-
-void
-__c_node::__add(__i_node* i)
-{
-    if (end_ == cap_)
-    {
-        size_t nc = 2*(cap_ - beg_);
-        if (nc == 0)
-            nc = 1;
-        __i_node** beg = (__i_node**)malloc(nc * sizeof(__i_node*));
-        if (beg == nullptr)
-            throw bad_alloc();
-        if (nc > 1)
-            memcpy(beg, beg_, nc/2*sizeof(__i_node*));
-        free(beg_);
-        beg_ = beg;
-        end_ = beg_ + nc/2;
-        cap_ = beg_ + nc;
-    }
-    *end_++ = i;
-}
-
-// private api
-
-_LIBCPP_HIDDEN
-__i_node*
-__libcpp_db::__insert_iterator(void* __i)
-{
-    if (__isz_ + 1 > __iend_ - __ibeg_)
-    {
-        size_t nc = __next_prime(2*(__iend_ - __ibeg_) + 1);
-        __i_node** ibeg = (__i_node**)calloc(nc, sizeof(void*));
-        if (ibeg == nullptr)
-            throw bad_alloc();
-        for (__i_node** p = __ibeg_; p != __iend_; ++p)
-        {
-            __i_node* q = *p;
-            while (q != nullptr)
-            {
-                size_t h = hash<void*>()(q->__i_) % nc;
-                __i_node* r = q->__next_;
-                q->__next_ = ibeg[h];
-                ibeg[h] = q;
-                q = r;
-            }
-        }
-        free(__ibeg_);
-        __ibeg_ = ibeg;
-        __iend_ = __ibeg_ + nc;
-    }
-    size_t hi = hash<void*>()(__i) % (__iend_ - __ibeg_);
-    __i_node* p = __ibeg_[hi];
-    __i_node* r = __ibeg_[hi] = (__i_node*)malloc(sizeof(__i_node));
-    if (r == nullptr)
-        throw bad_alloc();
-    ::new(r) __i_node(__i, p, nullptr);
-    ++__isz_;
-    return r;
-}
-
-_LIBCPP_HIDDEN
-__i_node*
-__libcpp_db::__find_iterator(const void* __i) const
-{
-    __i_node* r = nullptr;
-    if (__ibeg_ != __iend_)
-    {
-        size_t h = hash<const void*>()(__i) % (__iend_ - __ibeg_);
-        for (__i_node* nd = __ibeg_[h]; nd != nullptr; nd = nd->__next_)
-        {
-            if (nd->__i_ == __i)
-            {
-                r = nd;
-                break;
-            }
-        }
-    }
-    return r;
-}
-
-_LIBCPP_HIDDEN
-void
-__c_node::__remove(__i_node* p)
-{
-    __i_node** r = find(beg_, end_, p);
-    _LIBCPP_ASSERT(r != end_, "debug mode internal logic error __c_node::__remove");
-    if (--end_ != r)
-        memmove(r, r+1, (end_ - r)*sizeof(__i_node*));
-}
-
-_LIBCPP_END_NAMESPACE_STD
--- a/src/exception.cpp
+++ b/src/exception.cpp
@@ -13,37 +13,28 @@
 #if __APPLE__
  #include <cxxabi.h>
  using namespace __cxxabiv1;
-  using namespace __cxxabiapple;
  // On Darwin, there are two STL shared libraries and a lower level ABI
  // shared libray.  The globals holding the current terminate handler and
  // current unexpected handler are in the ABI library.
  #define __terminate_handler  __cxxabiapple::__cxa_terminate_handler
  #define __unexpected_handler __cxxabiapple::__cxa_unexpected_handler
-  #define HAVE_DEPENDENT_EH_ABI 1
-#elif defined(LIBCXXRT)
-  #include <cxxabi.h>
-  using namespace __cxxabiv1;
-  #define HAVE_DEPENDENT_EH_ABI 1
 #else  // __APPLE__
  static std::terminate_handler  __terminate_handler;
  static std::unexpected_handler __unexpected_handler;
 #endif  // __APPLE__

-#ifndef LIBCXXRT
-// libcxxrt provides implementations of these functions itself.
 std::unexpected_handler
-std::set_unexpected(std::unexpected_handler func) _NOEXCEPT
+std::set_unexpected(std::unexpected_handler func) throw()
 {
    return __sync_lock_test_and_set(&__unexpected_handler, func);
 }

 std::unexpected_handler
-std::get_unexpected() _NOEXCEPT
+std::get_unexpected() throw()
 {
    return __sync_fetch_and_add(&__unexpected_handler, (std::unexpected_handler)0);
 }

-_ATTRIBUTE(noreturn)
 void
 std::unexpected()
 {
@@ -53,20 +44,19 @@ std::unexpected()
 }

 std::terminate_handler
-std::set_terminate(std::terminate_handler func) _NOEXCEPT
+std::set_terminate(std::terminate_handler func) throw()
 {
    return __sync_lock_test_and_set(&__terminate_handler, func);
 }

 std::terminate_handler
-std::get_terminate() _NOEXCEPT
+std::get_terminate() throw()
 {
    return __sync_fetch_and_add(&__terminate_handler, (std::terminate_handler)0);
 }

-_ATTRIBUTE(noreturn)
 void
-std::terminate() _NOEXCEPT
+std::terminate()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
    try
@@ -84,71 +74,70 @@ std::terminate() _NOEXCEPT
    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
 }
-#endif // LIBCXXRT

-bool std::uncaught_exception() _NOEXCEPT
+bool std::uncaught_exception() throw()
 {
 #if __APPLE__
    // on Darwin, there is a helper function so __cxa_get_globals is private
    return __cxxabiapple::__cxa_uncaught_exception();
-#elif LIBCXXRT
-    __cxa_eh_globals * globals = __cxa_get_globals();
-    return (globals->uncaughtExceptions != 0);
 #else  // __APPLE__
    #warning uncaught_exception not yet implemented
    ::abort();
+    // Not provided by Ubuntu gcc-4.2.4's cxxabi.h.
+    // __cxa_eh_globals * globals = __cxa_get_globals();
+    // return (globals->uncaughtExceptions != 0);
 #endif  // __APPLE__
 }

 namespace std
 {

-exception::~exception() _NOEXCEPT
+exception::~exception() throw()
 {
 }

-bad_exception::~bad_exception() _NOEXCEPT
+bad_exception::~bad_exception() throw()
 {
 }

-const char* exception::what() const _NOEXCEPT
+const char* exception::what() const throw()
 {
  return "std::exception";
 }

-const char* bad_exception::what() const _NOEXCEPT
+const char* bad_exception::what() const throw()
 {
  return "std::bad_exception";
 }

-exception_ptr::~exception_ptr() _NOEXCEPT
+exception_ptr::~exception_ptr()
 {
-#if HAVE_DEPENDENT_EH_ABI
-    __cxa_decrement_exception_refcount(__ptr_);
+#if __APPLE__
+    __cxxabiapple::__cxa_decrement_exception_refcount(__ptr_);
 #else
    #warning exception_ptr not yet implemented
    ::abort();
 #endif  // __APPLE__
 }

-exception_ptr::exception_ptr(const exception_ptr& other) _NOEXCEPT
+exception_ptr::exception_ptr(const exception_ptr& other)
    : __ptr_(other.__ptr_)
 {
-#if HAVE_DEPENDENT_EH_ABI
-    __cxa_increment_exception_refcount(__ptr_);
+#if __APPLE__
+    __cxxabiapple::__cxa_increment_exception_refcount(__ptr_);
 #else
    #warning exception_ptr not yet implemented
    ::abort();
 #endif  // __APPLE__
 }

-exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
+exception_ptr& exception_ptr::operator=(const exception_ptr& other)
 {
-#if HAVE_DEPENDENT_EH_ABI
+#if __APPLE__
    if (__ptr_ != other.__ptr_)
    {
-        __cxa_increment_exception_refcount(other.__ptr_);
-        __cxa_decrement_exception_refcount(__ptr_);
+        __cxxabiapple::__cxa_increment_exception_refcount(other.__ptr_);
+        __cxxabiapple::__cxa_decrement_exception_refcount(__ptr_);
        __ptr_ = other.__ptr_;
    }
    return *this;
@@ -158,18 +147,17 @@ exception_ptr& exception_ptr::operator=(const exception_ptr& other) _NOEXCEPT
 #endif  // __APPLE__
 }

-nested_exception::nested_exception() _NOEXCEPT
+nested_exception::nested_exception()
    : __ptr_(current_exception())
 {
 }

-nested_exception::~nested_exception() _NOEXCEPT
+nested_exception::~nested_exception()
 {
 }

-_ATTRIBUTE(noreturn)
 void
-nested_exception::rethrow_nested() const
+nested_exception::rethrow_nested /*[[noreturn]]*/ () const
 {
    if (__ptr_ == nullptr)
        terminate();
@@ -178,14 +166,14 @@ nested_exception::rethrow_nested() const

 } // std

-std::exception_ptr std::current_exception() _NOEXCEPT
+std::exception_ptr std::current_exception()
 {
-#if HAVE_DEPENDENT_EH_ABI
+#if __APPLE__
    // be nicer if there was a constructor that took a ptr, then
    // this whole function would be just:
    //    return exception_ptr(__cxa_current_primary_exception());
    std::exception_ptr ptr;
-    ptr.__ptr_ = __cxa_current_primary_exception();
+    ptr.__ptr_ = __cxxabiapple::__cxa_current_primary_exception();
    return ptr;
 #else  // __APPLE__
    #warning exception_ptr not yet implemented
@@ -195,8 +183,8 @@ std::exception_ptr std::current_exception() _NOEXCEPT

 void std::rethrow_exception(exception_ptr p)
 {
-#if HAVE_DEPENDENT_EH_ABI
-    __cxa_rethrow_primary_exception(p.__ptr_);
+#if __APPLE__
+    __cxxabiapple::__cxa_rethrow_primary_exception(p.__ptr_);
    // if p.__ptr_ is NULL, above returns so we terminate
    terminate();
 #else  // __APPLE__
--- a/src/future.cpp
+++ b/src/future.cpp
@@ -16,12 +16,12 @@ class _LIBCPP_HIDDEN __future_error_category
    : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const;
    virtual string message(int ev) const;
 };

 const char*
-__future_error_category::name() const _NOEXCEPT
+__future_error_category::name() const
 {
    return "future";
 }
@@ -59,12 +59,8 @@ future_error::future_error(error_code __ec)
 {
 }

-future_error::~future_error() _NOEXCEPT
-{
-}
-
 void
-__assoc_sub_state::__on_zero_shared() _NOEXCEPT
+__assoc_sub_state::__on_zero_shared()
 {
    delete this;
 }
@@ -73,10 +69,8 @@ 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();
@@ -86,10 +80,8 @@ 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();
@@ -99,10 +91,8 @@ 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();
@@ -113,10 +103,8 @@ 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();
@@ -167,18 +155,14 @@ __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();
 }
@@ -218,50 +202,40 @@ 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);
 }

--- a/src/ios.cpp
+++ b/src/ios.cpp
@@ -38,12 +38,12 @@ class _LIBCPP_HIDDEN __iostream_category
    : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const;
    virtual string message(int ev) const;
 };

 const char*
-__iostream_category::name() const _NOEXCEPT
+__iostream_category::name() const
 {
    return "iostream";
 }
@@ -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 = _VSTD::max(2 * __iarray_cap_, req_size);
+            newcap = _STD::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 = _VSTD::max(2 * __parray_cap_, req_size);
+            newcap = _STD::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 = _VSTD::max(2 * __event_cap_, req_size);
+            newcap = _STD::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)
 {
-    _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_);
+    _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_);
    locale& lhs_loc = *(locale*)&__loc_;
    locale& rhs_loc = *(locale*)&rhs.__loc_;
-    _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_);
+    _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_);
 }

 void
--- a/src/iostream.cpp
+++ b/src/iostream.cpp
@@ -33,11 +33,11 @@ ios_base::Init __start_std_streams;
 ios_base::Init::Init()
 {
    cin.tie(&cout);
-    _VSTD::unitbuf(cerr);
+    _STD::unitbuf(cerr);
    cerr.tie(&cout);

    wcin.tie(&wcout);
-    _VSTD::unitbuf(wcerr);
+    _STD::unitbuf(wcerr);
    wcerr.tie(&wcout);
 }

--- a/src/locale.cpp
+++ b/src/locale.cpp
--- a/src/memory.cpp
+++ b/src/memory.cpp
@@ -16,14 +16,14 @@ namespace

 template <class T>
 inline T
-increment(T& t) _NOEXCEPT
+increment(T& t)
 {
    return __sync_add_and_fetch(&t, 1);
 }

 template <class T>
 inline T
-decrement(T& t) _NOEXCEPT
+decrement(T& t)
 {
    return __sync_add_and_fetch(&t, -1);
 }
@@ -32,10 +32,10 @@ decrement(T& t) _NOEXCEPT

 const allocator_arg_t allocator_arg = allocator_arg_t();

-bad_weak_ptr::~bad_weak_ptr() _NOEXCEPT {}
+bad_weak_ptr::~bad_weak_ptr() throw() {}

 const char*
-bad_weak_ptr::what() const _NOEXCEPT
+bad_weak_ptr::what() const throw()
 {
    return "bad_weak_ptr";
 }
@@ -45,13 +45,13 @@ __shared_count::~__shared_count()
 }

 void
-__shared_count::__add_shared() _NOEXCEPT
+__shared_count::__add_shared()
 {
    increment(__shared_owners_);
 }

 bool
-__shared_count::__release_shared() _NOEXCEPT
+__shared_count::__release_shared()
 {
    if (decrement(__shared_owners_) == -1)
    {
@@ -66,33 +66,33 @@ __shared_weak_count::~__shared_weak_count()
 }

 void
-__shared_weak_count::__add_shared() _NOEXCEPT
+__shared_weak_count::__add_shared()
 {
    __shared_count::__add_shared();
 }

 void
-__shared_weak_count::__add_weak() _NOEXCEPT
+__shared_weak_count::__add_weak()
 {
    increment(__shared_weak_owners_);
 }

 void
-__shared_weak_count::__release_shared() _NOEXCEPT
+__shared_weak_count::__release_shared()
 {
    if (__shared_count::__release_shared())
        __release_weak();
 }

 void
-__shared_weak_count::__release_weak() _NOEXCEPT
+__shared_weak_count::__release_weak()
 {
    if (decrement(__shared_weak_owners_) == -1)
        __on_zero_shared_weak();
 }

 __shared_weak_count*
-__shared_weak_count::lock() _NOEXCEPT
+__shared_weak_count::lock()
 {
    long object_owners = __shared_owners_;
    while (object_owners != -1)
@@ -112,7 +112,7 @@ __shared_weak_count::lock() _NOEXCEPT
 #ifndef _LIBCPP_NO_RTTI

 const void*
-__shared_weak_count::__get_deleter(const type_info&) const _NOEXCEPT
+__shared_weak_count::__get_deleter(const type_info&) const
 {
    return 0;
 }
@@ -135,7 +135,7 @@ undeclare_no_pointers(char*, size_t)
 }

 pointer_safety
-get_pointer_safety() _NOEXCEPT
+get_pointer_safety()
 {
    return pointer_safety::relaxed;
 }
--- a/src/new.cpp
+++ b/src/new.cpp
@@ -27,10 +27,7 @@

 __attribute__((__weak__, __visibility__("default")))
 void *
-operator new(std::size_t size)
-#if !__has_feature(cxx_noexcept)
-    throw(std::bad_alloc)
-#endif
+operator new(std::size_t size) throw (std::bad_alloc)
 {
    if (size == 0)
        size = 1;
@@ -54,7 +51,7 @@ operator new(std::size_t size)

 __attribute__((__weak__, __visibility__("default")))
 void*
-operator new(size_t size, const std::nothrow_t&) _NOEXCEPT
+operator new(size_t size, const std::nothrow_t&) throw()
 {
    void* p = 0;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -73,17 +70,14 @@ 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
+operator new[](size_t size) throw (std::bad_alloc)
 {
    return ::operator new(size);
 }

 __attribute__((__weak__, __visibility__("default")))
 void*
-operator new[](size_t size, const std::nothrow_t& nothrow) _NOEXCEPT
+operator new[](size_t size, const std::nothrow_t& nothrow) throw()
 {
    void* p = 0;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -102,7 +96,7 @@ operator new[](size_t size, const std::nothrow_t& nothrow) _NOEXCEPT

 __attribute__((__weak__, __visibility__("default")))
 void
-operator delete(void* ptr) _NOEXCEPT
+operator delete(void* ptr) throw ()
 {
    if (ptr)
        ::free(ptr);
@@ -110,21 +104,21 @@ operator delete(void* ptr) _NOEXCEPT

 __attribute__((__weak__, __visibility__("default")))
 void
-operator delete(void* ptr, const std::nothrow_t&) _NOEXCEPT
+operator delete(void* ptr, const std::nothrow_t&) throw ()
 {
    ::operator delete(ptr);
 }

 __attribute__((__weak__, __visibility__("default")))
 void
-operator delete[] (void* ptr) _NOEXCEPT
+operator delete[] (void* ptr) throw ()
 {
    ::operator delete (ptr);
 }

 __attribute__((__weak__, __visibility__("default")))
 void
-operator delete[] (void* ptr, const std::nothrow_t&) _NOEXCEPT
+operator delete[] (void* ptr, const std::nothrow_t&) throw ()
 {
    ::operator delete[](ptr);
 }
@@ -135,41 +129,41 @@ namespace std
 const nothrow_t nothrow = {};

 new_handler
-set_new_handler(new_handler handler) _NOEXCEPT
+set_new_handler(new_handler handler) throw()
 {
    return __sync_lock_test_and_set(&__new_handler, handler);
 }

 new_handler
-get_new_handler() _NOEXCEPT
+get_new_handler() throw()
 {
    return __sync_fetch_and_add(&__new_handler, (new_handler)0);
 }

-bad_alloc::bad_alloc() _NOEXCEPT
+bad_alloc::bad_alloc() throw()
 {
 }

-bad_alloc::~bad_alloc() _NOEXCEPT
+bad_alloc::~bad_alloc() throw()
 {
 }

 const char*
-bad_alloc::what() const _NOEXCEPT
+bad_alloc::what() const throw()
 {
    return "std::bad_alloc";
 }

-bad_array_new_length::bad_array_new_length() _NOEXCEPT
+bad_array_new_length::bad_array_new_length() throw()
 {
 }

-bad_array_new_length::~bad_array_new_length() _NOEXCEPT
+bad_array_new_length::~bad_array_new_length() throw()
 {
 }

 const char*
-bad_array_new_length::what() const _NOEXCEPT
+bad_array_new_length::what() const throw()
 {
    return "bad_array_new_length";
 }
--- a/src/regex.cpp
+++ b/src/regex.cpp
@@ -229,7 +229,7 @@ string
 __get_collation_name(const char* s)
 {
    const collationnames* i =
-            _VSTD::lower_bound(begin(collatenames), end(collatenames), s, use_strcmp());
+            _STD::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 =
-            _VSTD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
+            _STD::lower_bound(begin(ClassNames), end(ClassNames), s, use_strcmp());
    ctype_base::mask r = 0;
    if (i != end(ClassNames) && strcmp(s, i->elem_) == 0)
    {
--- a/src/stdexcept.cpp
+++ b/src/stdexcept.cpp
@@ -34,13 +34,13 @@ private:
    static const std::ptrdiff_t offset = static_cast<std::ptrdiff_t>(2*sizeof(unused_t) +
                                                                       sizeof(count_t));

-    count_t& count() const _NOEXCEPT {return (count_t&)(*(str_ - sizeof(count_t)));}
+    count_t& count() const throw() {return (count_t&)(*(str_ - sizeof(count_t)));}
 public:
    explicit __libcpp_nmstr(const char* msg);
    __libcpp_nmstr(const __libcpp_nmstr& s) _LIBCPP_CANTTHROW;
    __libcpp_nmstr& operator=(const __libcpp_nmstr& s) _LIBCPP_CANTTHROW;
    ~__libcpp_nmstr() _LIBCPP_CANTTHROW;
-    const char* c_str() const _NOEXCEPT {return str_;}
+    const char* c_str() const throw() {return str_;}
 };

 __libcpp_nmstr::__libcpp_nmstr(const char* msg)
@@ -98,14 +98,14 @@ logic_error::logic_error(const char* msg)
    ::new(&s) __libcpp_nmstr(msg);
 }

-logic_error::logic_error(const logic_error& le) _NOEXCEPT
+logic_error::logic_error(const logic_error& le) throw()
 {
    __libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
    ::new(&s) __libcpp_nmstr((const __libcpp_nmstr&)le.__imp_);
 }

 logic_error&
-logic_error::operator=(const logic_error& le) _NOEXCEPT
+logic_error::operator=(const logic_error& le) throw()
 {
    __libcpp_nmstr& s1 = (__libcpp_nmstr&)__imp_;
    const __libcpp_nmstr& s2 = (const __libcpp_nmstr&)le.__imp_;
@@ -113,14 +113,14 @@ logic_error::operator=(const logic_error& le) _NOEXCEPT
    return *this;
 }

-logic_error::~logic_error() _NOEXCEPT
+logic_error::~logic_error() throw()
 {
    __libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
    s.~__libcpp_nmstr();
 }

 const char*
-logic_error::what() const _NOEXCEPT
+logic_error::what() const throw()
 {
    __libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
    return s.c_str();
@@ -138,14 +138,14 @@ runtime_error::runtime_error(const char* msg)
    ::new(&s) __libcpp_nmstr(msg);
 }

-runtime_error::runtime_error(const runtime_error& le) _NOEXCEPT
+runtime_error::runtime_error(const runtime_error& le) throw()
 {
    __libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
    ::new(&s) __libcpp_nmstr((const __libcpp_nmstr&)le.__imp_);
 }

 runtime_error&
-runtime_error::operator=(const runtime_error& le) _NOEXCEPT
+runtime_error::operator=(const runtime_error& le) throw()
 {
    __libcpp_nmstr& s1 = (__libcpp_nmstr&)__imp_;
    const __libcpp_nmstr& s2 = (const __libcpp_nmstr&)le.__imp_;
@@ -153,26 +153,26 @@ runtime_error::operator=(const runtime_error& le) _NOEXCEPT
    return *this;
 }

-runtime_error::~runtime_error() _NOEXCEPT
+runtime_error::~runtime_error() throw()
 {
    __libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
    s.~__libcpp_nmstr();
 }

 const char*
-runtime_error::what() const _NOEXCEPT
+runtime_error::what() const throw()
 {
    __libcpp_nmstr& s = (__libcpp_nmstr&)__imp_;
    return s.c_str();
 }

-domain_error::~domain_error() _NOEXCEPT {}
-invalid_argument::~invalid_argument() _NOEXCEPT {}
-length_error::~length_error() _NOEXCEPT {}
-out_of_range::~out_of_range() _NOEXCEPT {}
+domain_error::~domain_error() throw() {}
+invalid_argument::~invalid_argument() throw() {}
+length_error::~length_error() throw() {}
+out_of_range::~out_of_range() throw() {}

-range_error::~range_error() _NOEXCEPT {}
-overflow_error::~overflow_error() _NOEXCEPT {}
-underflow_error::~underflow_error() _NOEXCEPT {}
+range_error::~range_error() throw() {}
+overflow_error::~overflow_error() throw() {}
+underflow_error::~underflow_error() throw() {}

 }  // std
--- a/src/string.cpp
+++ b/src/string.cpp
@@ -11,9 +11,6 @@
 #include "cstdlib"
 #include "cwchar"
 #include "cerrno"
-#if _WIN32
-#include "support/win32/support.h"
-#endif // _WIN32

 _LIBCPP_BEGIN_NAMESPACE_STD

@@ -22,6 +19,52 @@ 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&);
--- a/src/strstream.cpp
+++ b/src/strstream.cpp
@@ -100,6 +100,41 @@ 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)
@@ -115,10 +150,10 @@ void
 strstreambuf::swap(strstreambuf& __rhs)
 {
    streambuf::swap(__rhs);
-    _VSTD::swap(__strmode_, __rhs.__strmode_);
-    _VSTD::swap(__alsize_, __rhs.__alsize_);
-    _VSTD::swap(__palloc_, __rhs.__palloc_);
-    _VSTD::swap(__pfree_, __rhs.__pfree_);
+    _STD::swap(__strmode_, __rhs.__strmode_);
+    _STD::swap(__alsize_, __rhs.__alsize_);
+    _STD::swap(__palloc_, __rhs.__palloc_);
+    _STD::swap(__pfree_, __rhs.__pfree_);
 }

 void
@@ -267,7 +302,7 @@ strstreambuf::seekoff(off_type __off, ios_base::seekdir __way, ios_base::openmod
        {
            char* newpos = eback() + newoff;
            if (pos_in)
-                setg(eback(), newpos, _VSTD::max(newpos, egptr()));
+                setg(eback(), newpos, _STD::max(newpos, egptr()));
            if (pos_out)
            {
                // min(pbase, newpos), newpos, epptr()
@@ -297,7 +332,7 @@ strstreambuf::seekpos(pos_type __sp, ios_base::openmode __which)
            {
                char* newpos = eback() + newoff;
                if (pos_in)
-                    setg(eback(), newpos, _VSTD::max(newpos, egptr()));
+                    setg(eback(), newpos, _STD::max(newpos, egptr()));
                if (pos_out)
                {
                    // min(pbase, newpos), newpos, epptr()
--- a/src/support/win32/locale_win32.cpp
+++ b/src/support/win32/locale_win32.cpp
@@ -1,94 +0,0 @@
-// -*- C++ -*-
-//===-------------------- support/win32/locale_win32.cpp ------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include "support/win32/locale_win32.h"
-
-#include <stdarg.h> // va_start, va_end
-
-// FIXME: base currently unused. Needs manual work to construct the new locale
-locale_t newlocale( int mask, const char * locale, locale_t /*base*/ )
-{
-    return _create_locale( mask, locale );
-}
-locale_t uselocale( locale_t newloc )
-{
-    locale_t old_locale = _get_current_locale();
-    // uselocale sets the thread's locale by definition, so unconditionally use thread-local locale
-    _configthreadlocale( _ENABLE_PER_THREAD_LOCALE );
-	// uselocale sets all categories
-	setlocale( LC_ALL, newloc->locinfo->lc_category[LC_ALL].locale );
-	// uselocale returns the old locale_t
-	return old_locale;
-}
-lconv *localeconv_l( locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return localeconv();
-}
-size_t mbrlen_l( const char *__restrict__ s, size_t n,
-                 mbstate_t *__restrict__ ps, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return mbrlen( s, n, ps );
-}
-size_t mbsrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                    size_t len, mbstate_t *__restrict__ ps, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return mbsrtowcs( dst, src, len, ps );
-}
-size_t wcrtomb_l( char *__restrict__ s, wchar_t wc, mbstate_t *__restrict__ ps,
-                  locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return wcrtomb( s, wc, ps );
-}
-size_t mbrtowc_l( wchar_t *__restrict__ pwc, const char *__restrict__ s,
-                  size_t n, mbstate_t *__restrict__ ps, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return mbrtowc( pwc, s, n, ps );
-}
-size_t mbsnrtowcs_l( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                     size_t nms, size_t len, mbstate_t *__restrict__ ps, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return mbsnrtowcs( dst, src, nms, len, ps );
-}
-size_t wcsnrtombs_l( char *__restrict__ dst, const wchar_t **__restrict__ src,
-                     size_t nwc, size_t len, mbstate_t *__restrict__ ps, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return wcsnrtombs( dst, src, nwc, len, ps );
-}
-wint_t btowc_l( int c, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return btowc( c );
-}
-int wctob_l( wint_t c, locale_t loc )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return wctob( c );
-}
-
-int asprintf_l( char **ret, locale_t loc, const char *format, ... )
-{
-    va_list ap;
-    va_start( ap, format );
-    int result = vasprintf_l( ret, loc, format, ap );
-    va_end(ap);
-    return result;
-}
-int vasprintf_l( char **ret, locale_t loc, const char *format, va_list ap )
-{
-    __locale_raii __current( uselocale(loc), uselocale );
-    return vasprintf( ret, format, ap );
-}
--- a/src/support/win32/support.cpp
+++ b/src/support/win32/support.cpp
@@ -1,70 +0,0 @@
-// -*- C++ -*-
-//===----------------------- support/win32/support.h ----------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-#include <support/win32/support.h>
-#include <stdarg.h> // va_start, va_end
-#include <stddef.h> // size_t
-#include <stdlib.h> // malloc
-#include <stdio.h>  // vsprintf, vsnprintf
-#include <string.h> // strcpy, wcsncpy
-
-int asprintf(char **sptr, const char *__restrict__ fmt, ...)
-{
-    va_list ap;
-    va_start(ap, fmt);
-    int result = vasprintf(sptr, fmt, ap);
-    va_end(ap);
-	return result;
-}
-int vasprintf( char **sptr, const char *__restrict__ fmt, va_list ap )
-{
-    *sptr = NULL;
-    int count = vsnprintf( *sptr, 0, fmt, ap );
-    if( (count >= 0) && ((*sptr = (char*)malloc(count+1)) != NULL) )
-    {
-        vsprintf( *sptr, fmt, ap );
-        sptr[count] = '\0';
-    }
-
-    return count;
-}
-
-// FIXME: use wcrtomb and avoid copy
-// use mbsrtowcs which is available, first copy first nwc elements of src
-size_t mbsnrtowcs( wchar_t *__restrict__ dst, const char **__restrict__ src,
-                   size_t nmc, size_t len, mbstate_t *__restrict__ ps )
-{
-    char* local_src = new char[nmc+1];
-    char* nmcsrc = local_src;
-    strncpy( nmcsrc, *src, nmc );
-    nmcsrc[nmc] = '\0';
-    const size_t result = mbsrtowcs( dst, const_cast<const char **>(&nmcsrc), len, ps );
-    // propagate error
-    if( nmcsrc == NULL )
-        *src = NULL;
-    delete[] local_src;
-    return result;
-}
-// FIXME: use wcrtomb and avoid copy
-// use wcsrtombs which is available, first copy first nwc elements of src
-size_t wcsnrtombs( char *__restrict__ dst, const wchar_t **__restrict__ src,
-                   size_t nwc, size_t len, mbstate_t *__restrict__ ps )
-{
-    wchar_t* local_src = new wchar_t[nwc];
-    wchar_t* nwcsrc = local_src;
-    wcsncpy(nwcsrc, *src, nwc);
-    nwcsrc[nwc] = '\0';
-    const size_t result = wcsrtombs( dst, const_cast<const wchar_t **>(&nwcsrc), len, ps );
-    // propogate error
-    if( nwcsrc == NULL )
-        *src = NULL;
-    delete[] nwcsrc;
-    return result;
-}
--- a/src/system_error.cpp
+++ b/src/system_error.cpp
@@ -15,28 +15,28 @@ _LIBCPP_BEGIN_NAMESPACE_STD

 // class error_category

-error_category::error_category() _NOEXCEPT
+error_category::error_category()
 {
 }

-error_category::~error_category() _NOEXCEPT
+error_category::~error_category()
 {
 }

 error_condition
-error_category::default_error_condition(int ev) const _NOEXCEPT
+error_category::default_error_condition(int ev) const
 {
    return error_condition(ev, *this);
 }

 bool
-error_category::equivalent(int code, const error_condition& condition) const _NOEXCEPT
+error_category::equivalent(int code, const error_condition& condition) const
 {
    return default_error_condition(code) == condition;
 }

 bool
-error_category::equivalent(const error_code& code, int condition) const _NOEXCEPT
+error_category::equivalent(const error_code& code, int condition) const
 {
    return *this == code.category() && code.value() == condition;
 }
@@ -51,12 +51,12 @@ class _LIBCPP_HIDDEN __generic_error_category
    : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const;
    virtual string message(int ev) const;
 };

 const char*
-__generic_error_category::name() const _NOEXCEPT
+__generic_error_category::name() const
 {
    return "generic";
 }
@@ -72,7 +72,7 @@ __generic_error_category::message(int ev) const
 }

 const error_category&
-generic_category() _NOEXCEPT
+generic_category()
 {
    static __generic_error_category s;
    return s;
@@ -82,13 +82,13 @@ class _LIBCPP_HIDDEN __system_error_category
    : public __do_message
 {
 public:
-    virtual const char* name() const _NOEXCEPT;
+    virtual const char* name() const;
    virtual string message(int ev) const;
-    virtual error_condition default_error_condition(int ev) const _NOEXCEPT;
+    virtual error_condition default_error_condition(int ev) const;
 };

 const char*
-__system_error_category::name() const _NOEXCEPT
+__system_error_category::name() const
 {
    return "system";
 }
@@ -104,7 +104,7 @@ __system_error_category::message(int ev) const
 }

 error_condition
-__system_error_category::default_error_condition(int ev) const _NOEXCEPT
+__system_error_category::default_error_condition(int ev) const
 {
 #ifdef ELAST
    if (ev > ELAST)
@@ -114,7 +114,7 @@ __system_error_category::default_error_condition(int ev) const _NOEXCEPT
 }

 const error_category&
-system_category() _NOEXCEPT
+system_category()
 {
    static __system_error_category s;
    return s;
@@ -147,7 +147,7 @@ system_error::__init(const error_code& ec, string what_arg)
            what_arg += ": ";
        what_arg += ec.message();
    }
-    return _VSTD::move(what_arg);
+    return _STD::move(what_arg);
 }

 system_error::system_error(error_code ec, const string& what_arg)
@@ -186,7 +186,7 @@ system_error::system_error(int ev, const error_category& ecat)
 {
 }

-system_error::~system_error() _NOEXCEPT
+system_error::~system_error() throw()
 {
 }

--- a/src/thread.cpp
+++ b/src/thread.cpp
@@ -12,9 +12,7 @@
 #include "vector"
 #include "future"
 #include <sys/types.h>
-#if !_WIN32
 #include <sys/sysctl.h>
-#endif // _WIN32

 _LIBCPP_BEGIN_NAMESPACE_STD

--- a/src/typeinfo.cpp
+++ b/src/typeinfo.cpp
@@ -13,30 +13,30 @@

 #include "typeinfo"

-std::bad_cast::bad_cast() _NOEXCEPT
+std::bad_cast::bad_cast() throw()
 {
 }

-std::bad_cast::~bad_cast() _NOEXCEPT
+std::bad_cast::~bad_cast() throw()
 {
 }

 const char*
-std::bad_cast::what() const _NOEXCEPT
+std::bad_cast::what() const throw()
 {
  return "std::bad_cast";
 }

-std::bad_typeid::bad_typeid() _NOEXCEPT
+std::bad_typeid::bad_typeid() throw()
 {
 }

-std::bad_typeid::~bad_typeid() _NOEXCEPT
+std::bad_typeid::~bad_typeid() throw()
 {
 }

 const char*
-std::bad_typeid::what() const _NOEXCEPT
+std::bad_typeid::what() const throw()
 {
  return "std::bad_typeid";
 }
--- a/test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
+++ b/test/algorithms/alg.sorting/alg.min.max/max_init_list.pass.cpp
@@ -18,7 +18,7 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    int i = std::max({2, 3, 1});
    assert(i == 3);
    i = std::max({2, 1, 3});
@@ -31,5 +31,5 @@ int main()
    assert(i == 3);
    i = std::max({1, 3, 2});
    assert(i == 3);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
+++ b/test/algorithms/alg.sorting/alg.min.max/max_init_list_comp.pass.cpp
@@ -19,7 +19,7 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    int i = std::max({2, 3, 1}, std::greater<int>());
    assert(i == 1);
    i = std::max({2, 1, 3}, std::greater<int>());
@@ -32,5 +32,5 @@ int main()
    assert(i == 1);
    i = std::max({1, 3, 2}, std::greater<int>());
    assert(i == 1);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
+++ b/test/algorithms/alg.sorting/alg.min.max/min_init_list.pass.cpp
@@ -18,7 +18,7 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    int i = std::min({2, 3, 1});
    assert(i == 1);
    i = std::min({2, 1, 3});
@@ -31,5 +31,5 @@ int main()
    assert(i == 1);
    i = std::min({1, 3, 2});
    assert(i == 1);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
+++ b/test/algorithms/alg.sorting/alg.min.max/min_init_list_comp.pass.cpp
@@ -19,7 +19,7 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    int i = std::min({2, 3, 1}, std::greater<int>());
    assert(i == 3);
    i = std::min({2, 1, 3}, std::greater<int>());
@@ -32,5 +32,5 @@ int main()
    assert(i == 3);
    i = std::min({1, 3, 2}, std::greater<int>());
    assert(i == 3);
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
+++ b/test/algorithms/alg.sorting/alg.min.max/minmax_init_list.pass.cpp
@@ -18,12 +18,12 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    assert((std::minmax({1, 2, 3}) == std::pair<int, int>(1, 3)));
    assert((std::minmax({1, 3, 2}) == std::pair<int, int>(1, 3)));
    assert((std::minmax({2, 1, 3}) == std::pair<int, int>(1, 3)));
    assert((std::minmax({2, 3, 1}) == std::pair<int, int>(1, 3)));
    assert((std::minmax({3, 1, 2}) == std::pair<int, int>(1, 3)));
    assert((std::minmax({3, 2, 1}) == std::pair<int, int>(1, 3)));
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
+++ b/test/algorithms/alg.sorting/alg.min.max/minmax_init_list_comp.pass.cpp
@@ -19,12 +19,12 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    assert((std::minmax({1, 2, 3}, std::greater<int>()) == std::pair<int, int>(3, 1)));
    assert((std::minmax({1, 3, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
    assert((std::minmax({2, 1, 3}, std::greater<int>()) == std::pair<int, int>(3, 1)));
    assert((std::minmax({2, 3, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
    assert((std::minmax({3, 1, 2}, std::greater<int>()) == std::pair<int, int>(3, 1)));
    assert((std::minmax({3, 2, 1}, std::greater<int>()) == std::pair<int, int>(3, 1)));
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
+++ b/test/containers/associative/map/map.cons/assign_initializer_list.pass.cpp
@@ -18,7 +18,7 @@

 int main()
 {
-#ifndef _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    typedef std::pair<const int, double> V;
    std::map<int, double> m =
                            {
@@ -41,5 +41,5 @@ int main()
    assert(*m.begin() == V(1, 1));
    assert(*next(m.begin()) == V(2, 1));
    assert(*next(m.begin(), 2) == V(3, 1));
-#endif  // _LIBCPP_HAS_NO_GENERALIZED_INITIALIZERS
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 }
--- a/test/containers/associative/map/map.cons/default_noexcept.pass.cpp
+++ b/test/containers/associative/map/map.cons/default_noexcept.pass.cpp
@@ -1,53 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <map>
-
-// map()
-//    noexcept(
-//        is_nothrow_default_constructible<allocator_type>::value &&
-//        is_nothrow_default_constructible<key_compare>::value &&
-//        is_nothrow_copy_constructible<key_compare>::value);
-
-// This tests a conforming extension
-
-#include <map>
-#include <cassert>
-
-#include "../../../MoveOnly.h"
-#include "../../../test_allocator.h"
-
-template <class T>
-struct some_comp
-{
-    typedef T value_type;
-    some_comp();
-};
-
-int main()
-{
-#if __has_feature(cxx_noexcept)
-    {
-        typedef std::map<MoveOnly, MoveOnly> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
-    }
-    {
-        typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_default_constructible<C>::value, "");
-    }
-    {
-        typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
-        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
-    }
-    {
-        typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
-        static_assert(!std::is_nothrow_default_constructible<C>::value, "");
-    }
-#endif
-}
--- a/test/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
+++ b/test/containers/associative/map/map.cons/dtor_noexcept.pass.cpp
@@ -1,51 +0,0 @@
-//===----------------------------------------------------------------------===//
-//
-//                     The LLVM Compiler Infrastructure
-//
-// This file is dual licensed under the MIT and the University of Illinois Open
-// Source Licenses. See LICENSE.TXT for details.
-//
-//===----------------------------------------------------------------------===//
-
-// <map>
-
-// ~map() // implied noexcept;
-
-#include <map>
-#include <cassert>
-
-#include "../../../MoveOnly.h"
-#include "../../../test_allocator.h"
-
-#if __has_feature(cxx_noexcept)
-
-template <class T>
-struct some_comp
-{
-    typedef T value_type;
-    ~some_comp() noexcept(false);
-};
-
-#endif
-
-int main()
-{
-#if __has_feature(cxx_noexcept)
-    {
-        typedef std::map<MoveOnly, MoveOnly> C;
-        static_assert(std::is_nothrow_destructible<C>::value, "");
-    }
-    {
-        typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, test_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_destructible<C>::value, "");
-    }
-    {
-        typedef std::map<MoveOnly, MoveOnly, std::less<MoveOnly>, other_allocator<MoveOnly>> C;
-        static_assert(std::is_nothrow_destructible<C>::value, "");
-    }
-    {
-        typedef std::map<MoveOnly, MoveOnly, some_comp<MoveOnly>> C;
-        static_assert(!std::is_nothrow_destructible<C>::value, "");
-    }
-#endif
-}
--- a/Show More
+++ b/Show More