<rdar://problem/8668832> Barolo11A: *** FAILED *** build failed: libcpp-8

git-svn-id: https://llvm.org/svn/llvm-project/libcxx/tags/libcpp-8.1@119179 91177308-0d34-0410-b5e6-96231b3b80d8
libcpp-8.1
2010-11-15 20:41:13 +00:00 · 2010-11-15 20:35:31 +00:00 · 2010-10-14 21:23:46 +00:00
4404 changed files with 29306 additions and 17738 deletions
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -1,159 +0,0 @@
-# See www/CMake.html for instructions on how to build libcxx with CMake.
-
-#===============================================================================
-# Setup Project
-#===============================================================================
-
-project(libcxx CXX C)
-cmake_minimum_required(VERSION 2.6.4)
-
-set(PACKAGE_NAME libcxx)
-set(PACKAGE_VERSION lll)
-set(PACKAGE_STRING "${PACKAGE_NAME} ${PACKAGE_VERSION}")
-set(PACKAGE_BUGREPORT "llvmbugs@cs.uiuc.edu")
-
-# Add path for custom modules
-set(CMAKE_MODULE_PATH
-  ${CMAKE_MODULE_PATH}
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake"
-  "${CMAKE_CURRENT_SOURCE_DIR}/cmake/Modules"
-  )
-
-# Require out of source build.
-include(MacroEnsureOutOfSourceBuild)
-MACRO_ENSURE_OUT_OF_SOURCE_BUILD(
- "${PROJECT_NAME} requires an out of source build. Please create a separate
- build directory and run 'cmake /path/to/${PROJECT_NAME} [options]' there."
- )
-
-#===============================================================================
-# Setup CMake Options
-#===============================================================================
-
-# Define options.
-option(LIBCXX_ENABLE_EXCEPTIONS "Use exceptions." ON)
-option(LIBCXX_ENABLE_RTTI "Use run time type information." ON)
-option(LIBCXX_ENABLE_ASSERTIONS "Enable assertions independent of build mode." ON)
-option(LIBCXX_ENABLE_PEDANTIC "Compile with pedantic enabled." ON)
-option(LIBCXX_ENABLE_WERROR "Fail and stop if a warning is triggered." OFF)
-option(LIBCXX_ENABLE_CXX0X "Enable -std=c++0x and use of c++0x language features if the compiler supports it." ON)
-option(LIBCXX_ENABLE_SHARED "Build libc++ as a shared library." ON)
-
-#===============================================================================
-# Configure System
-#===============================================================================
-
-# Get triples.
-include(GetTriple)
-get_host_triple(LIBCXX_HOST_TRIPLE
-  LIBCXX_HOST_ARCH
-  LIBCXX_HOST_VENDOR
-  LIBCXX_HOST_OS
-  )
-set(LIBCXX_HOST_TRIPLE ${LIBCXX_HOST_TRIPLE} CACHE STRING "Host triple.")
-get_target_triple(LIBCXX_TARGET_TRIPLE
-  LIBCXX_TARGET_ARCH
-  LIBCXX_TARGET_VENDOR
-  LIBCXX_TARGET_OS
-  )
-set(LIBCXX_TARGET_TRIPLE ${LIBCXX_TARGET_TRIPLE} CACHE STRING "Target triple.")
-
-# Configure compiler.
-include(config-ix)
-
-#===============================================================================
-# Setup Compiler Flags
-#===============================================================================
-
-# Get required flags.
-# On all systems the system c++ standard library headers need to be excluded.
-if (MSVC)
-  # MSVC only has -X, which disables all default includes; including the crt.
-  # Thus, we do nothing and hope we don't accidentally include any of the C++
-  # headers.
-else()
-  if (LIBCXX_HAS_NOSTDINCXX_FLAG)
-    set(LIBCXX_CXX_REQUIRED_FLAGS -nostdinc++)
-  endif()
-  if (LIBCXX_ENABLE_CXX0X AND LIBCXX_HAS_STDCXX0X_FLAG)
-    list(APPEND LIBCXX_CXX_REQUIRED_FLAGS -std=c++0x)
-  endif()
-endif()
-
-macro(append_if list condition var)
-  if (${condition})
-    list(APPEND ${list} ${var})
-  endif()
-endmacro()
-
-# Get warning flags
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WALL_FLAG -Wall)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_W_FLAG -W)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WNO_UNUSED_PARAMETER_FLAG -Wno-unused-parameter)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WWRITE_STRINGS_FLAG -Wwrite-strings)
-append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WNO_LONG_LONG_FLAG -Wno-long-long)
-if (LIBCXX_ENABLE_WERROR)
-  append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WERROR_FLAG -Werror)
-  append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_WX_FLAG -WX)
-endif()
-if (LIBCXX_ENABLE_PEDANTIC)
-  append_if(LIBCXX_WARNING_FLAGS LIBCXX_HAS_PEDANTIC_FLAG -pedantic)
-endif()
-
-# Get feature flags.
-# Exceptions
-if (LIBCXX_ENABLE_EXCEPTIONS)
-  # Catches C++ exceptions only and tells the compiler to assume that extern C
-  # functions never throw a C++ exception.
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_EHSC_FLAG -EHsc)
-else()
-  list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_LIBCPP_NO_EXCEPTIONS)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_NO_EHS_FLAG -EHs-)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_NO_EHA_FLAG -EHa-)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_FNO_EXCEPTIONS_FLAG -fno-exceptions)
-endif()
-# RTTI
-if (NOT LIBCXX_ENABLE_RTTI)
-  list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_LIBCPP_NO_RTTI)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_NO_GR_FLAG -GR-)
-  append_if(LIBCXX_CXX_FEATURE_FLAGS LIBCXX_HAS_FNO_RTTI_FLAG -fno-rtti)
-endif()
-# Assert
-if (LLVM_ENABLE_ASSERTIONS)
-  # MSVC doesn't like _DEBUG on release builds. See PR 4379.
-  if (NOT MSVC)
-    list(APPEND LIBCXX_CXX_FEATURE_FLAGS -D_DEBUG)
-  endif()
-  # On Release builds cmake automatically defines NDEBUG, so we
-  # explicitly undefine it:
-  if (uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
-    list(APPEND LIBCXX_CXX_FEATURE_FLAGS -UNDEBUG)
-  endif()
-else()
-  if (NOT uppercase_CMAKE_BUILD_TYPE STREQUAL "RELEASE")
-    list(APPEND LIBCXX_CXX_FEATURE_FLAGS -DNDEBUG)
-  endif()
-endif()
-
-# This is the _ONLY_ place where add_definitions is called.
-add_definitions(
- ${LIBCXX_CXX_REQUIRED_FLAGS}
- ${LIBCXX_CXX_WARNING_FLAGS}
- ${LIBCXX_CXX_FEATURE_FLAGS}
- )
-
-#===============================================================================
-# Setup Source Code
-#===============================================================================
-
-include_directories(include)
-
-# Add source code. This also contains all of the logic for deciding linker flags
-# soname, etc...
-add_subdirectory(lib)
-
-#===============================================================================
-# Setup Tests
-#===============================================================================
-
-add_subdirectory(test)
--- a/CREDITS.TXT
+++ b/CREDITS.TXT
@@ -1,18 +0,0 @@
-This file is a partial list of people who have contributed to the LLVM/libc++
-project.  If you have contributed a patch or made some other contribution to
-LLVM/libc++, please submit a patch to this file to add yourself, and it will be
-done!
-
-The list is sorted by surname and formatted to allow easy grepping and
-beautification by scripts.  The fields are: name (N), email (E), web-address
-(W), PGP key ID and fingerprint (P), description (D), and snail-mail address
-(S).
-
-N: Howard Hinnant
-E: hhinnant@apple.com
-D: Architect and primary author of libc++
-
-N: Marshall Clow
-E: marshall@idio.com
-E: mclow@qualcomm.com
-D: Minor patches and bug fixes.
--- a/LICENSE.TXT
+++ b/LICENSE.TXT
@@ -1,21 +1,10 @@
 ==============================================================================
-libc++ License
+LLVM Release License
 ==============================================================================
-
-The libc++ library is dual licensed under both the University of Illinois
-"BSD-Like" license and the MIT license.  As a user of this code you may choose
-to use it under either license.  As a contributor, you agree to allow your code
-to be used under both.
-
-Full text of the relevant licenses is included below.
-
-==============================================================================
-
 University of Illinois/NCSA
 Open Source License

-Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
-
+Copyright (c) 2007-2010 University of Illinois at Urbana-Champaign.
 All rights reserved.

 Developed by:
@@ -54,23 +43,20 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE
 SOFTWARE.

 ==============================================================================
+The LLVM software contains code written by third parties.  Such software will
+have its own individual LICENSE.TXT file in the directory in which it appears.
+This file will describe the copyrights, license, and restrictions which apply
+to that code.

-Copyright (c) 2009-2010 by the contributors listed in CREDITS.TXT
+The disclaimer of warranty in the University of Illinois Open Source License
+applies to all code in the LLVM Distribution, and nothing in any of the
+other licenses gives permission to use the names of the LLVM Team or the
+University of Illinois to endorse or promote products derived from this
+Software.

-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+The following pieces of software have additional or alternate copyrights,
+licenses, and/or restrictions:

-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
+Program             Directory
+-------             ---------
+<none yet>
--- a/cmake/Modules/GetTriple.cmake
+++ b/cmake/Modules/GetTriple.cmake
@@ -1,53 +0,0 @@
-# Define functions to get the host and target triple.
-
-function(get_host_triple out out_arch out_vendor out_os)
-  # Get the architecture.
-  set(arch ${CMAKE_HOST_SYSTEM_PROCESSOR})
-  if (arch STREQUAL "x86")
-    set(arch "i686")
-  endif()
-  # Get the vendor.
-  if (${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Darwin")
-    set(vendor "apple")
-  else()
-    set(vendor "pc")
-  endif()
-  # Get os.
-  if (${CMAKE_HOST_SYSTEM_NAME} STREQUAL "Windows")
-    set(os "win32")
-  else()
-    string(TOLOWER ${CMAKE_HOST_SYSTEM_NAME} os)
-  endif()
-  set(triple "${arch}-${vendor}-${os}")
-  set(${out} ${triple} PARENT_SCOPE)
-  set(${out_arch} ${arch} PARENT_SCOPE)
-  set(${out_vendor} ${vendor} PARENT_SCOPE)
-  set(${out_os} ${os} PARENT_SCOPE)
-  message(STATUS "Host triple: ${triple}")
-endfunction()
-
-function(get_target_triple out out_arch out_vendor out_os)
-  # Get the architecture.
-  set(arch ${CMAKE_SYSTEM_PROCESSOR})
-  if (arch STREQUAL "x86")
-    set(arch "i686")
-  endif()
-  # Get the vendor.
-  if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-    set(vendor "apple")
-  else()
-    set(vendor "pc")
-  endif()
-  # Get os.
-  if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-    set(os "win32")
-  else()
-    string(TOLOWER ${CMAKE_SYSTEM_NAME} os)
-  endif()
-  set(triple "${arch}-${vendor}-${os}")
-  set(${out} ${triple} PARENT_SCOPE)
-  set(${out_arch} ${arch} PARENT_SCOPE)
-  set(${out_vendor} ${vendor} PARENT_SCOPE)
-  set(${out_os} ${os} PARENT_SCOPE)
-  message(STATUS "Target triple: ${triple}")
-endfunction()
--- a/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake
+++ b/cmake/Modules/MacroEnsureOutOfSourceBuild.cmake
@@ -1,18 +0,0 @@
-# MACRO_ENSURE_OUT_OF_SOURCE_BUILD(<errorMessage>)
-
-macro( MACRO_ENSURE_OUT_OF_SOURCE_BUILD _errorMessage )
-
-string( COMPARE EQUAL "${CMAKE_SOURCE_DIR}" "${CMAKE_BINARY_DIR}" _insource )
-if( _insource )
- message( SEND_ERROR "${_errorMessage}" )
- message( FATAL_ERROR
- "In-source builds are not allowed.
- CMake would overwrite the makefiles distributed with Compiler-RT.
- Please create a directory and run cmake from there, passing the path
- to this source directory as the last argument.
- This process created the file `CMakeCache.txt' and the directory `CMakeFiles'.
- Please delete them."
- )
-endif( _insource )
-
-endmacro( MACRO_ENSURE_OUT_OF_SOURCE_BUILD )
--- a/cmake/config-ix.cmake
+++ b/cmake/config-ix.cmake
@@ -1,37 +0,0 @@
-include(CheckLibraryExists)
-include(CheckCXXCompilerFlag)
-
-# Check compiler flags
-check_cxx_compiler_flag(-std=c++0x            LIBCXX_HAS_STDCXX0X_FLAG)
-check_cxx_compiler_flag(-fPIC                 LIBCXX_HAS_FPIC_FLAG)
-check_cxx_compiler_flag(-nodefaultlibs        LIBCXX_HAS_NODEFAULTLIBS_FLAG)
-check_cxx_compiler_flag(-nostdinc++           LIBCXX_HAS_NOSTDINCXX_FLAG)
-check_cxx_compiler_flag(-Wall                 LIBCXX_HAS_WALL_FLAG)
-check_cxx_compiler_flag(-W                    LIBCXX_HAS_W_FLAG)
-check_cxx_compiler_flag(-Wno-unused-parameter LIBCXX_HAS_WNO_UNUSED_PARAMETER_FLAG)
-check_cxx_compiler_flag(-Wwrite-strings       LIBCXX_HAS_WWRITE_STRINGS_FLAG)
-check_cxx_compiler_flag(-Wno-long-long        LIBCXX_HAS_WNO_LONG_LONG_FLAG)
-check_cxx_compiler_flag(-pedantic             LIBCXX_HAS_PEDANTIC_FLAG)
-check_cxx_compiler_flag(-Werror               LIBCXX_HAS_WERROR_FLAG)
-check_cxx_compiler_flag(-fno-exceptions       LIBCXX_HAS_FNO_EXCEPTIONS_FLAG)
-check_cxx_compiler_flag(-fno-rtti             LIBCXX_HAS_FNO_RTTI_FLAG)
-check_cxx_compiler_flag(/WX                   LIBCXX_HAS_WX_FLAG)
-check_cxx_compiler_flag(/EHsc                 LIBCXX_HAS_EHSC_FLAG)
-check_cxx_compiler_flag(/EHs-                 LIBCXX_HAS_NO_EHS_FLAG)
-check_cxx_compiler_flag(/EHa-                 LIBCXX_HAS_NO_EHA_FLAG)
-check_cxx_compiler_flag(/GR-                  LIBCXX_HAS_NO_GR_FLAG)
-
-# Check libraries
-check_library_exists(pthread pthread_create "" LIBCXX_HAS_PTHREAD_LIB)
-check_library_exists(c printf "" LIBCXX_HAS_C_LIB)
-check_library_exists(m ccos "" LIBCXX_HAS_M_LIB)
-check_library_exists(gcc_s __gcc_personality_v0 "" LIBCXX_HAS_GCC_S_LIB)
-
-# Check C++0x features
-if (LIBCXX_ENABLE_CXX0X)
-  if (LIBCXX_HAS_STDCXX0X_FLAG)
-    set(CMAKE_REQUIRED_DEFINITIONS -std=c++0x)
-  endif()
-else()
-  set(LIBCXX_HAS_STDCXX0X_FLAG FALSE)
-endif()
--- a/include/__bit_reference
+++ b/include/__bit_reference
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/__config
+++ b/include/__config
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -82,7 +82,7 @@

 #define _LIBCPP_CANTTHROW __attribute__ ((__nothrow__))

-#define _LIBCPP_ALWAYS_INLINE  __attribute__ ((__visibility__("hidden"), __always_inline__))
+#define _LIBCPP_ALWAYS_INLINE  __attribute__((__always_inline__))

 #if defined(__clang__)

@@ -144,19 +144,22 @@ typedef __char32_t char32_t;
 #define _LIBCPP_HAS_NO_VARIADICS
 #endif

-#if !(__has_feature(cxx_trailing_return))
-#define _LIBCPP_HAS_NO_TRAILING_RETURN
-#endif
-
-// Inline namespaces are available in Clang regardless of C++ dialect.
+#if __has_feature(cxx_inline_namespaces)
 #define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {inline namespace _LIBCPP_NAMESPACE {
 #define _LIBCPP_END_NAMESPACE_STD  } }
 #define _STD std::_LIBCPP_NAMESPACE

 namespace std {
-  inline namespace _LIBCPP_NAMESPACE {
-  }
+inline namespace _LIBCPP_NAMESPACE {
 }
+using namespace _LIBCPP_NAMESPACE;
+}
+
+#else  // __has_feature(cxx_inline_namespaces)
+#define _LIBCPP_BEGIN_NAMESPACE_STD namespace std {
+#define _LIBCPP_END_NAMESPACE_STD }
+#define _STD std
+#endif  // __has_feature(cxx_inline_namespaces)

 #if !(__has_feature(cxx_constexpr))
 #define _LIBCPP_HAS_NO_CONSTEXPR
@@ -184,13 +187,9 @@ namespace std {
 #define _LIBCPP_HAS_NO_UNICODE_CHARS
 #define _LIBCPP_HAS_NO_VARIADICS
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
-#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS

 #else  // __GXX_EXPERIMENTAL_CXX0X__

-#define _LIBCPP_HAS_NO_TRAILING_RETURN
-#define _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-
 #if !(__GNUC__ >= 4 && __GNUC_MINOR__ >= 3)
 #define _LIBCPP_HAS_NO_RVALUE_REFERENCES
 #endif
--- a/include/__functional_03
+++ b/include/__functional_03
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/__functional_base
+++ b/include/__functional_base
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/__functional_base_03
+++ b/include/__functional_base_03
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/__hash_table
+++ b/include/__hash_table
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -29,9 +29,9 @@ template <class _NodePtr>
 struct __hash_node_base
 {
    typedef __hash_node_base __first_node;
- //   typedef _NodePtr pointer;
+    typedef _NodePtr pointer;

-    _NodePtr    __next_;
+    pointer    __next_;

    _LIBCPP_INLINE_VISIBILITY __hash_node_base() : __next_(nullptr) {}
 };
@@ -85,7 +85,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return _STD::addressof(__node_->__value_);}
+        pointer operator->() const {return addressof(__node_->__value_);}

    _LIBCPP_INLINE_VISIBILITY
    __hash_iterator& operator++()
@@ -163,7 +163,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY
        reference operator*() const {return __node_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
-        pointer operator->() const {return _STD::addressof(__node_->__value_);}
+        pointer operator->() const {return addressof(__node_->__value_);}

    _LIBCPP_INLINE_VISIBILITY
    __hash_const_iterator& operator++()
@@ -433,7 +433,7 @@ public:
    void operator()(pointer __p)
    {
        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -798,7 +798,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__hash_table(__hash_table&& __u)
    if (size() > 0)
    {
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(addressof(__p1_.first()));
        __u.__p1_.first().__next_ = nullptr;
        __u.size() = 0;
    }
@@ -822,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>(_STD::addressof(__p1_.first()));
+                static_cast<__node_pointer>(addressof(__p1_.first()));
            size() = __u.size();
            __u.size() = 0;
        }
@@ -875,7 +875,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__deallocate(__node_pointer __np)
    while (__np != nullptr)
    {
        __node_pointer __next = __np->__next_;
-        __node_traits::destroy(__na, _STD::addressof(__np->__value_));
+        __node_traits::destroy(__na, addressof(__np->__value_));
        __node_traits::deallocate(__na, __np, 1);
        __np = __next;
    }
@@ -914,7 +914,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__move_assign(
    if (size() > 0)
    {
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(addressof(__p1_.first()));
        __u.__p1_.first().__next_ = nullptr;
        __u.size() = 0;
    }
@@ -1131,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>(_STD::addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(addressof(__p1_.first()));
            __nd->__next_ = __pn->__next_;
            __pn->__next_ = __nd;
            // fix up __bucket_list_
@@ -1169,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>(_STD::addressof(__p1_.first()));
+        __pn = static_cast<__node_pointer>(addressof(__p1_.first()));
        __cp->__next_ = __pn->__next_;
        __pn->__next_ = __cp;
        // fix up __bucket_list_
@@ -1275,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>(_STD::addressof(__p1_.first()));
+            __pn = static_cast<__node_pointer>(addressof(__p1_.first()));
            __h->__next_ = __pn->__next_;
            __pn->__next_ = __h.get();
            // fix up __bucket_list_
@@ -1433,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>(_STD::addressof(__p1_.first())));
+        __node_pointer __pp(static_cast<__node_pointer>(addressof(__p1_.first())));
        __node_pointer __cp = __pp->__next_;
        if (__cp != nullptr)
        {
@@ -1533,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, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = hash_function()(__h->__value_);
    __h->__next_ = nullptr;
@@ -1549,7 +1549,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(value_type&& __v,
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__na, addressof(__h->__value_), _STD::move(__v));
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = __hash;
    __h->__next_ = nullptr;
@@ -1564,7 +1564,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = hash_function()(__h->__value_);
    __h->__next_ = nullptr;
@@ -1580,7 +1580,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::__construct_node(const value_type& __v
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    __h->__hash_ = __hash;
    __h->__next_ = nullptr;
@@ -1658,7 +1658,7 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::remove(const_iterator __p)
    // Fix up __bucket_list_
        // if __pn is not in same bucket (before begin is not in same bucket) &&
        //    if __cn->__next_ is not in same bucket (nullptr is not in same bucket)
-    if (__pn == _STD::addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
+    if (__pn == addressof(__p1_.first()) || __pn->__hash_ % __bc != __chash)
    {
        if (__cn->__next_ == nullptr || __cn->__next_->__hash_ % __bc != __chash)
            __bucket_list_[__chash] = nullptr;
@@ -1791,10 +1791,10 @@ __hash_table<_Tp, _Hash, _Equal, _Alloc>::swap(__hash_table& __u)
    __p3_.swap(__u.__p3_);
    if (size() > 0)
        __bucket_list_[__p1_.first().__next_->__hash_ % bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__p1_.first()));
+            static_cast<__node_pointer>(addressof(__p1_.first()));
    if (__u.size() > 0)
        __u.__bucket_list_[__u.__p1_.first().__next_->__hash_ % __u.bucket_count()] =
-            static_cast<__node_pointer>(_STD::addressof(__u.__p1_.first()));
+            static_cast<__node_pointer>(addressof(__u.__p1_.first()));
 }

 template <class _Tp, class _Hash, class _Equal, class _Alloc>
--- a/include/__locale
+++ b/include/__locale
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -55,8 +55,7 @@ public:
    explicit locale(const string&);
    locale(const locale&, const char*, category);
    locale(const locale&, const string&, category);
-    template <class _Facet>
-        _LIBCPP_INLINE_VISIBILITY locale(const locale&, _Facet*);
+    template <class _Facet> locale(const locale&, _Facet*);
    locale(const locale&, const locale&, category);

    ~locale() throw();
--- a/include/__mutex_base
+++ b/include/__mutex_base
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -18,16 +18,6 @@

 #pragma GCC system_header

-#ifdef _LIBCPP_SHARED_LOCK
-
-namespace ting {
-template <class> class shared_lock;
-template <class> class upgrade_lock;
-}
-
-#endif  // _LIBCPP_SHARED_LOCK
-
-
 _LIBCPP_BEGIN_NAMESPACE_STD

 class _LIBCPP_VISIBLE mutex
@@ -153,28 +143,6 @@ public:
            __u.__owns_ = false;
            return *this;
        }
-
-#ifdef _LIBCPP_SHARED_LOCK
-
-    unique_lock(ting::shared_lock<mutex_type>&&, try_to_lock_t);
-    template <class _Clock, class _Duration>
-        unique_lock(ting::shared_lock<mutex_type>&&,
-                    const chrono::time_point<_Clock, _Duration>&);
-    template <class _Rep, class _Period>
-        unique_lock(ting::shared_lock<mutex_type>&&,
-                    const chrono::duration<_Rep, _Period>&);
-
-    explicit unique_lock(ting::upgrade_lock<mutex_type>&&);
-    unique_lock(ting::upgrade_lock<mutex_type>&&, try_to_lock_t);
-    template <class _Clock, class _Duration>
-        unique_lock(ting::upgrade_lock<mutex_type>&&,
-                    const chrono::time_point<_Clock, _Duration>&);
-    template <class _Rep, class _Period>
-        unique_lock(ting::upgrade_lock<mutex_type>&&,
-                    const chrono::duration<_Rep, _Period>&);
-
-#endif  // _LIBCPP_SHARED_LOCK
-
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    void lock();
@@ -414,11 +382,11 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
                             const chrono::duration<_Rep, _Period>& __d)
 {
    using namespace chrono;
-    system_clock::time_point __s_now = system_clock::now();
-    steady_clock::time_point __c_now = steady_clock::now();
+    system_clock::time_point     __s_now = system_clock::now();
+    monotonic_clock::time_point  __c_now = monotonic_clock::now();
    __do_timed_wait(__lk, __s_now + __ceil<nanoseconds>(__d));
-    return steady_clock::now() - __c_now < __d ? cv_status::no_timeout :
-                                                 cv_status::timeout;
+    return monotonic_clock::now() - __c_now < __d ? cv_status::no_timeout :
+                                                    cv_status::timeout;
 }

 template <class _Rep, class _Period, class _Predicate>
@@ -428,7 +396,7 @@ condition_variable::wait_for(unique_lock<mutex>& __lk,
                             const chrono::duration<_Rep, _Period>& __d,
                             _Predicate __pred)
 {
-    return wait_until(__lk, chrono::steady_clock::now() + __d,
+    return wait_until(__lk, chrono::monotonic_clock::now() + __d,
                      _STD::move(__pred));
 }

--- a/include/__split_buffer
+++ b/include/__split_buffer
@@ -85,20 +85,22 @@ public:
    void shrink_to_fit();
    void push_front(const_reference __x);
    void push_back(const_reference __x);
-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void push_front(value_type&& __x);
    void push_back(value_type&& __x);
-#if !defined(_LIBCPP_HAS_NO_VARIADICS)
    template <class... _Args>
        void emplace_back(_Args&&... __args);
-#endif  // !defined(_LIBCPP_HAS_NO_VARIADICS)
-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    _LIBCPP_INLINE_VISIBILITY void pop_front() {__destruct_at_begin(__begin_+1);}
    _LIBCPP_INLINE_VISIBILITY void pop_back() {__destruct_at_end(__end_-1);}

    void __construct_at_end(size_type __n);
+        void __construct_at_end(size_type __n, false_type);
+        void __construct_at_end(size_type __n, true_type);
    void __construct_at_end(size_type __n, const_reference __x);
+        void __construct_at_end(size_type __n, const_reference __x, false_type);
+        void __construct_at_end(size_type __n, const_reference __x, true_type);
    template <class _InputIter>
        typename enable_if
        <
@@ -116,12 +118,12 @@ public:
        __construct_at_end(_ForwardIterator __first, _ForwardIterator __last);

    _LIBCPP_INLINE_VISIBILITY void __destruct_at_begin(pointer __new_begin)
-        {__destruct_at_begin(__new_begin, is_trivially_destructible<value_type>());}
+        {__destruct_at_begin(__new_begin, has_trivial_destructor<value_type>());}
        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)
-        {__destruct_at_end(__new_last, is_trivially_destructible<value_type>());}
+        {__destruct_at_end(__new_last, has_trivial_destructor<value_type>());}
        void __destruct_at_end(pointer __new_last, false_type);
        void __destruct_at_end(pointer __new_last, true_type);

@@ -188,8 +190,16 @@ __split_buffer<_Tp, _Allocator>::__invariants() const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
+{
+    __construct_at_end(__n, __is_zero_default_constructible<value_type>());
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
 {
    __alloc_rr& __a = this->__alloc();
    do
@@ -200,6 +210,15 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
    } while (__n > 0);
 }

+template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, true_type)
+{
+    _STD::memset(this->__end_, 0, __n*sizeof(value_type));
+    this->__end_ += __n;
+}
+
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
@@ -207,8 +226,17 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n)
 //  Postcondition:  size() == old size() + __n
 //  Postcondition:  [i] == __x for all i in [size() - __n, __n)
 template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 void
 __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
+{
+    __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
+                                                         has_trivial_copy_assign<value_type>::value>());
+}
+
+template <class _Tp, class _Allocator>
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, false_type)
 {
    __alloc_rr& __a = this->__alloc();
    do
@@ -219,6 +247,15 @@ __split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_referen
    } while (__n > 0);
 }

+template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
+void
+__split_buffer<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, true_type)
+{
+    _STD::fill_n(this->__end_, __n, __x);
+    this->__end_ += __n;
+}
+
 template <class _Tp, class _Allocator>
 template <class _InputIter>
 typename enable_if
--- a/include/__sso_allocator
+++ b/include/__sso_allocator
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/__std_stream
+++ b/include/__std_stream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -97,7 +97,7 @@ typename __stdinbuf<_CharT>::int_type
 __stdinbuf<_CharT>::__getchar(bool __consume)
 {
    char __extbuf[__limit];
-    int __nread = _STD::max(1, __encoding_);
+    int __nread = max(1, __encoding_);
    for (int __i = 0; __i < __nread; ++__i)
    {
        char __c = getc(__file_);
--- a/include/__tree
+++ b/include/__tree
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -523,7 +523,7 @@ public:
    void operator()(pointer __p)
    {
        if (__value_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -769,7 +769,6 @@ public:
    typedef typename __alloc_traits::difference_type difference_type;

    typedef __tree_node<value_type, typename __alloc_traits::void_pointer> __node;
-    typedef __tree_node_base<typename __alloc_traits::void_pointer> __node_base;
    typedef typename __alloc_traits::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
            rebind_alloc<__node>
@@ -780,10 +779,10 @@ public:
    typedef allocator_traits<__node_allocator>       __node_traits;
    typedef typename __node_traits::pointer          __node_pointer;
    typedef typename __node_traits::const_pointer    __node_const_pointer;
-    typedef typename __node_base::pointer            __node_base_pointer;
-    typedef typename __node_base::const_pointer      __node_base_const_pointer;
+    typedef typename __node::base::pointer           __node_base_pointer;
+    typedef typename __node::base::const_pointer     __node_base_const_pointer;
 private:
-    typedef typename __node_base::base __end_node_t;
+    typedef typename __node::base::base __end_node_t;
    typedef typename pointer_traits<__node_pointer>::template
 #ifndef _LIBCPP_HAS_NO_TEMPLATE_ALIASES
            rebind<__end_node_t>
@@ -911,12 +910,13 @@ public:
        iterator __insert_multi(_V&& __v);
    template <class _V>
        iterator __insert_multi(const_iterator __p, _V&& __v);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    pair<iterator, bool> __insert_unique(const value_type& __v);
    iterator __insert_unique(const_iterator __p, const value_type& __v);
    iterator __insert_multi(const value_type& __v);
    iterator __insert_multi(const_iterator __p, const value_type& __v);
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES

    pair<iterator, bool> __node_insert_unique(__node_pointer __nd);
    iterator             __node_insert_unique(const_iterator __p,
@@ -997,19 +997,19 @@ public:

    __node_holder remove(const_iterator __p);
 private:
-    typename __node_base::pointer&
-        __find_leaf_low(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
-        __find_leaf_high(typename __node_base::pointer& __parent, const value_type& __v);
-    typename __node_base::pointer&
+    typename __node::base::pointer&
+        __find_leaf_low(typename __node::base::pointer& __parent, const value_type& __v);
+    typename __node::base::pointer&
+        __find_leaf_high(typename __node::base::pointer& __parent, const value_type& __v);
+    typename __node::base::pointer&
        __find_leaf(const_iterator __hint,
-                    typename __node_base::pointer& __parent, const value_type& __v);
+                    typename __node::base::pointer& __parent, const value_type& __v);
    template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(typename __node_base::pointer& __parent, const _Key& __v);
+        typename __node::base::pointer&
+        __find_equal(typename __node::base::pointer& __parent, const _Key& __v);
    template <class _Key>
-        typename __node_base::pointer&
-        __find_equal(const_iterator __hint, typename __node_base::pointer& __parent,
+        typename __node::base::pointer&
+        __find_equal(const_iterator __hint, typename __node::base::pointer& __parent,
                     const _Key& __v);

 #if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS)
@@ -1373,7 +1373,7 @@ __tree<_Tp, _Compare, _Allocator>::destroy(__node_pointer __nd)
        destroy(static_cast<__node_pointer>(__nd->__left_));
        destroy(static_cast<__node_pointer>(__nd->__right_));
        __node_allocator& __na = __node_alloc();
-        __node_traits::destroy(__na, _STD::addressof(__nd->__value_));
+        __node_traits::destroy(__na, addressof(__nd->__value_));
        __node_traits::deallocate(__na, __nd, 1);
    }
 }
@@ -1411,8 +1411,8 @@ __tree<_Tp, _Compare, _Allocator>::clear()
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node::base::pointer& __parent,
                                                   const value_type& __v)
 {
    __node_pointer __nd = __root();
@@ -1450,8 +1450,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_low(typename __node_base::pointer
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node::base::pointer& __parent,
                                                    const value_type& __v)
 {
    __node_pointer __nd = __root();
@@ -1492,9 +1492,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf_high(typename __node_base::pointe
 // Set __parent to parent of null leaf
 // Return reference to null leaf
 template <class _Tp, class _Compare, class _Allocator>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
-                                               typename __node_base::pointer& __parent,
+                                               typename __node::base::pointer& __parent,
                                               const value_type& __v)
 {
    if (__hint == end() || !value_comp()(*__hint, __v))  // check before
@@ -1528,8 +1528,8 @@ __tree<_Tp, _Compare, _Allocator>::__find_leaf(const_iterator __hint,
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
-__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& __parent,
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
+__tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node::base::pointer& __parent,
                                                const _Key& __v)
 {
    __node_pointer __nd = __root();
@@ -1577,9 +1577,9 @@ __tree<_Tp, _Compare, _Allocator>::__find_equal(typename __node_base::pointer& _
 // If __v exists, set parent to node of __v and return reference to node of __v
 template <class _Tp, class _Compare, class _Allocator>
 template <class _Key>
-typename __tree<_Tp, _Compare, _Allocator>::__node_base::pointer&
+typename __tree<_Tp, _Compare, _Allocator>::__node::base::pointer&
 __tree<_Tp, _Compare, _Allocator>::__find_equal(const_iterator __hint,
-                                                typename __node_base::pointer& __parent,
+                                                typename __node::base::pointer& __parent,
                                                const _Key& __v)
 {
    if (__hint == end() || value_comp()(__v, *__hint))  // check before
@@ -1655,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, _STD::addressof(__h->__value_), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__value_constructed = true;
    return __h;
 }
@@ -1728,11 +1728,18 @@ template <class _V>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(_V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
-    pair<iterator, bool> __r = __node_insert_unique(__h.get());
-    if (__r.second)
-        __h.release();
-    return __r;
+    __node_base_pointer __parent;
+    __node_base_pointer& __child = __find_equal(__parent, __v);
+    __node_pointer __r = static_cast<__node_pointer>(__child);
+    bool __inserted = false;
+    if (__child == nullptr)
+    {
+        __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+        __insert_node_at(__parent, __child, __h.get());
+        __r = __h.release();
+        __inserted = true;
+    }
+    return pair<iterator, bool>(iterator(__r), __inserted);
 }

 template <class _Tp, class _Compare, class _Allocator>
@@ -1740,11 +1747,16 @@ template <class _V>
 typename __tree<_Tp, _Compare, _Allocator>::iterator
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(const_iterator __p, _V&& __v)
 {
-    __node_holder __h = __construct_node(_STD::forward<_V>(__v));
-    iterator __r = __node_insert_unique(__p, __h.get());
-    if (__r.__ptr_ == __h.get())
-        __h.release();
-    return __r;
+    __node_base_pointer __parent;
+    __node_base_pointer& __child = __find_equal(__p, __parent, __v);
+    __node_pointer __r = static_cast<__node_pointer>(__child);
+    if (__child == nullptr)
+    {
+        __node_holder __h = __construct_node(_STD::forward<_V>(__v));
+        __insert_node_at(__parent, __child, __h.get());
+        __r = __h.release();
+    }
+    return iterator(__r);
 }

 template <class _Tp, class _Compare, class _Allocator>
@@ -1779,13 +1791,11 @@ __tree<_Tp, _Compare, _Allocator>::__construct_node(const value_type& __v)
 {
    __node_allocator& __na = __node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__na, addressof(__h->__value_), __v);
    __h.get_deleter().__value_constructed = true;
    return _STD::move(__h);
 }

-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 template <class _Tp, class _Compare, class _Allocator>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__insert_unique(const value_type& __v)
@@ -1842,6 +1852,8 @@ __tree<_Tp, _Compare, _Allocator>::__insert_multi(const_iterator __p, const valu
    return iterator(__h.release());
 }

+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+
 template <class _Tp, class _Compare, class _Allocator>
 pair<typename __tree<_Tp, _Compare, _Allocator>::iterator, bool>
 __tree<_Tp, _Compare, _Allocator>::__node_insert_unique(__node_pointer __nd)
@@ -1907,7 +1919,7 @@ __tree<_Tp, _Compare, _Allocator>::erase(const_iterator __p)
        __begin_node() = __r.__ptr_;
    --size();
    __node_allocator& __na = __node_alloc();
-    __node_traits::destroy(__na, const_cast<value_type*>(_STD::addressof(*__p)));
+    __node_traits::destroy(__na, const_cast<value_type*>(addressof(*__p)));
    __tree_remove(__end_node()->__left_,
                  static_cast<__node_base_pointer>(__np));
    __node_traits::deallocate(__na, __np, 1);
--- a/include/__tuple
+++ b/include/__tuple
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -26,68 +26,29 @@
 _LIBCPP_BEGIN_NAMESPACE_STD

 template <class _Tp> class _LIBCPP_VISIBLE tuple_size;
-
-template <class _Tp>
-class _LIBCPP_VISIBLE tuple_size<const _Tp>
-    : public tuple_size<_Tp> {};
-
-template <class _Tp>
-class _LIBCPP_VISIBLE tuple_size<volatile _Tp>
-    : public tuple_size<_Tp> {};
-
-template <class _Tp>
-class _LIBCPP_VISIBLE tuple_size<const volatile _Tp>
-    : public tuple_size<_Tp> {};
-
 template <size_t _Ip, class _Tp> class _LIBCPP_VISIBLE tuple_element;

-template <size_t _Ip, class _Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, const _Tp>
-{
-public:
-    typedef typename add_const<typename tuple_element<_Ip, _Tp>::type>::type type;
-};
-
-template <size_t _Ip, class _Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, volatile _Tp>
-{
-public:
-    typedef typename add_volatile<typename tuple_element<_Ip, _Tp>::type>::type type;
-};
-
-template <size_t _Ip, class _Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, const volatile _Tp>
-{
-public:
-    typedef typename add_cv<typename tuple_element<_Ip, _Tp>::type>::type type;
-};
-
 template <class ..._Tp> class _LIBCPP_VISIBLE tuple;
 template <class _T1, class _T2> class _LIBCPP_VISIBLE pair;
 template <class _Tp, size_t _Size> struct _LIBCPP_VISIBLE array;

 template <class _Tp> struct __tuple_like : false_type {};

-template <class _Tp> struct __tuple_like<const _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<volatile _Tp> : public __tuple_like<_Tp> {};
-template <class _Tp> struct __tuple_like<const volatile _Tp> : public __tuple_like<_Tp> {};
-
-template <class... _Tp> struct __tuple_like<tuple<_Tp...> > : true_type {};
+template <class... _Tp> struct __tuple_like<tuple<_Tp...>> : true_type {};
+template <class... _Tp> struct __tuple_like<const tuple<_Tp...>> : true_type {};
 template <class _T1, class _T2> struct __tuple_like<pair<_T1, _T2> > : true_type {};
+template <class _T1, class _T2> struct __tuple_like<const pair<_T1, _T2> > : true_type {};
 template <class _Tp, size_t _Size> struct __tuple_like<array<_Tp, _Size> > : true_type {};
+template <class _Tp, size_t _Size> struct __tuple_like<const array<_Tp, _Size> > : true_type {};

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

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

-template <size_t _Ip, class ..._Tp>
-typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&&);
-
 template <size_t _Ip, class _T1, class _T2>
 typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 get(pair<_T1, _T2>&);
@@ -96,10 +57,6 @@ template <size_t _Ip, class _T1, class _T2>
 const typename tuple_element<_Ip, pair<_T1, _T2> >::type&
 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>&&);
-
 template <size_t _Ip, class _Tp, size_t _Size>
 _Tp&
 get(array<_Tp, _Size>&);
@@ -108,10 +65,6 @@ template <size_t _Ip, class _Tp, size_t _Size>
 const _Tp&
 get(const array<_Tp, _Size>&);

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

 template <size_t...> struct __tuple_indices {};
@@ -143,7 +96,7 @@ struct __make_tuple_indices
 template <class ..._Tp> struct __tuple_types {};

 template <size_t _Ip>
-class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<> >
+class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<>>
 {
 public:
    static_assert(_Ip == 0, "tuple_element index out of range");
@@ -151,26 +104,26 @@ public:
 };

 template <class _Hp, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...> >
+class _LIBCPP_VISIBLE tuple_element<0, __tuple_types<_Hp, _Tp...>>
 {
 public:
    typedef _Hp type;
 };

 template <size_t _Ip, class _Hp, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...> >
+class _LIBCPP_VISIBLE tuple_element<_Ip, __tuple_types<_Hp, _Tp...>>
 {
 public:
-    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip-1, __tuple_types<_Tp...>>::type type;
 };

 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...> >
+class _LIBCPP_VISIBLE tuple_size<__tuple_types<_Tp...>>
    : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };

-template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...> > : true_type {};
+template <class... _Tp> struct __tuple_like<__tuple_types<_Tp...>> : true_type {};

 // __make_tuple_types

@@ -212,17 +165,13 @@ template <bool, class _Tp, class _Up>
 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...> >
+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> {};
+                               __tuple_convertible_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...>>::value> {};

 template <>
-struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<> >
+struct __tuple_convertible_imp<true, __tuple_types<>, __tuple_types<>>
    : public true_type {};

 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
@@ -243,13 +192,13 @@ template <bool, class _Tp, class _Up>
 struct __tuple_assignable_imp : public false_type {};

 template <class _Tp0, class ..._Tp, class _Up0, class ..._Up>
-struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...> >
+struct __tuple_assignable_imp<true, __tuple_types<_Tp0, _Tp...>, __tuple_types<_Up0, _Up...>>
    : public integral_constant<bool,
-                               is_assignable<_Up0&, _Tp0>::value &&
-                               __tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...> >::value> {};
+                               __is_assignable<_Up0&, _Tp0>::value &&
+                               __tuple_assignable_imp<true, __tuple_types<_Tp...>, __tuple_types<_Up...>>::value> {};

 template <>
-struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<> >
+struct __tuple_assignable_imp<true, __tuple_types<>, __tuple_types<>>
    : public true_type {};

 template <class _Tp, class _Up, bool = __tuple_like<typename remove_reference<_Tp>::type>::value,
--- a/include/__tuple_03
+++ b/include/__tuple_03
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/algorithm
+++ b/include/algorithm
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -256,7 +256,7 @@ template <class RandomAccessIterator, class RandomNumberGenerator>

 template<class RandomAccessIterator, class UniformRandomNumberGenerator>
    void shuffle(RandomAccessIterator first, RandomAccessIterator last,
-                 UniformRandomNumberGenerator&& g);
+                 UniformRandomNumberGenerator& g);

 template <class InputIterator, class Predicate>
    bool
@@ -1438,7 +1438,7 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_trivially_copy_assignable<_Tp>::value,
+    has_trivial_copy_assign<_Tp>::value,
    _Tp*
 >::type
 __unwrap_iter(move_iterator<_Tp*> __i)
@@ -1450,7 +1450,7 @@ template <class _Tp>
 inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
-    is_trivially_copy_assignable<_Tp>::value,
+    has_trivial_copy_assign<_Tp>::value,
    _Tp*
 >::type
 __unwrap_iter(__wrap_iter<_Tp*> __i)
@@ -1473,7 +1473,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
    _Up*
 >::type
 __copy(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1508,7 +1508,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
    _Up*
 >::type
 __copy_backward(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1559,17 +1559,8 @@ typename enable_if
 >::type
 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
 {
-    if (__n > 0)
-    {
+    for (; __n > 0; --__n, ++__first, ++__result)
        *__result = *__first;
-        ++__result;
-        for (--__n; __n > 0; --__n)
-        {
-            ++__first;
-            *__result = *__first;
-            ++__result;
-        }
-    }
    return __result;
 }

@@ -1582,7 +1573,7 @@ typename enable_if
 >::type
 copy_n(_InputIterator __first, _Size __n, _OutputIterator __result)
 {
-    return _STD::copy(__first, __first + __n, __result);
+    return copy(__first, __first + __n, __result);
 }

 // move
@@ -1602,7 +1593,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
    _Up*
 >::type
 __move(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1637,7 +1628,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
    is_same<typename remove_const<_Tp>::type, _Up>::value &&
-    is_trivially_copy_assignable<_Up>::value,
+    has_trivial_copy_assign<_Up>::value,
    _Up*
 >::type
 __move_backward(_Tp* __first, _Tp* __last, _Up* __result)
@@ -1775,7 +1766,7 @@ fill_n(_OutputIterator __first, _Size __n, const _Tp& __value)
 {
   return _STD::__fill_n(__first, __n, __value, integral_constant<bool,
                                              is_pointer<_OutputIterator>::value &&
-                                              is_trivially_copy_assignable<_Tp>::value     &&
+                                              has_trivial_copy_assign<_Tp>::value     &&
                                              sizeof(_Tp) == 1>());
 }

@@ -2178,7 +2169,7 @@ rotate(_ForwardIterator __first, _ForwardIterator __middle, _ForwardIterator __l
                                   typename iterator_traits<_ForwardIterator>::iterator_category,
                                   random_access_iterator_tag
                               >::value &&
-                               is_trivially_copy_assignable
+                               has_trivial_copy_assign
                               <
                                   typename iterator_traits<_ForwardIterator>::value_type
                               >::value
@@ -2695,11 +2686,7 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last)
        _D __uid;
        __rs_default __g = __rs_get();
        for (--__last, --__d; __first < __last; ++__first, --__d)
-        {
-            difference_type __i = __uid(__g, _P(0, __d));
-            if (__i != difference_type(0))
-                swap(*__first, *(__first + __i));
-        }
+            swap(*__first, *(__first + __uid(__g, _P(0, __d))));
    }
 }

@@ -2717,20 +2704,13 @@ random_shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
    if (__d > 1)
    {
        for (--__last; __first < __last; ++__first, --__d)
-        {
-            difference_type __i = __rand(__d);
-            swap(*__first, *(__first + __i));
-        }
+            swap(*__first, *(__first + __rand(__d)));
    }
 }

 template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
    void shuffle(_RandomAccessIterator __first, _RandomAccessIterator __last,
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-                 _UniformRandomNumberGenerator&& __g)
-#else
                 _UniformRandomNumberGenerator& __g)
-#endif
 {
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
    typedef uniform_int_distribution<ptrdiff_t> _D;
@@ -2740,11 +2720,7 @@ template<class _RandomAccessIterator, class _UniformRandomNumberGenerator>
    {
        _D __uid;
        for (--__last, --__d; __first < __last; ++__first, --__d)
-        {
-            difference_type __i = __uid(__g, _P(0, __d));
-            if (__i != difference_type(0))
-                swap(*__first, *(__first + __i));
-        }
+            swap(*__first, *(__first + __uid(__g, _P(0, __d))));
    }
 }

@@ -3443,8 +3419,8 @@ __sort(_RandomAccessIterator __first, _RandomAccessIterator __last, _Compare __c
    // _Compare is known to be a reference type
    typedef typename iterator_traits<_RandomAccessIterator>::difference_type difference_type;
    typedef typename iterator_traits<_RandomAccessIterator>::value_type value_type;
-    const difference_type __limit = is_trivially_copy_constructible<value_type>::value &&
-                                    is_trivially_copy_assignable<value_type>::value ? 30 : 6;
+    const difference_type __limit = has_trivial_copy_constructor<value_type>::value &&
+                                    has_trivial_copy_assign<value_type>::value ? 30 : 6;
    while (true)
    {
    __restart:
@@ -4078,7 +4054,7 @@ __inplace_merge(_BidirectionalIterator __first, _BidirectionalIterator __middle,
 template <class _Tp>
 struct __inplace_merge_switch
 {
-    static const unsigned value = is_trivially_copy_assignable<_Tp>::value;
+    static const unsigned value = has_trivial_copy_assign<_Tp>::value;
 };

 template <class _BidirectionalIterator, class _Compare>
@@ -4246,7 +4222,7 @@ __stable_sort_move(_RandomAccessIterator __first1, _RandomAccessIterator __last1
 template <class _Tp>
 struct __stable_sort_switch
 {
-    static const unsigned value = 128*is_trivially_copy_assignable<_Tp>::value;
+    static const unsigned value = 128*has_trivial_copy_assign<_Tp>::value;
 };

 template <class _Compare, class _RandomAccessIterator>
--- a/include/array
+++ b/include/array
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -94,7 +94,6 @@ 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>&);
 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

@@ -296,18 +295,6 @@ get(const array<_Tp, _Size>& __a)
    return __a[_Ip];
 }

-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <size_t _Ip, class _Tp, size_t _Size>
-_LIBCPP_INLINE_VISIBILITY inline
-_Tp&&
-get(array<_Tp, _Size>&& __a)
-{
-    return _STD::move(__a[_Ip]);
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 _LIBCPP_END_NAMESPACE_STD

 #endif  // _LIBCPP_ARRAY
--- a/include/atomic
+++ b/include/atomic
--- a/include/bitset
+++ b/include/bitset
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -40,10 +40,7 @@ public:
    // 23.3.5.1 constructors:
    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,
-                        charT zero = charT('0'), charT one = charT('1'));
+    explicit bitset( const char* str );
    template<class charT, class traits, class Allocator>
        explicit bitset(const basic_string<charT,traits,Allocator>& str,
                        typename basic_string<charT,traits,Allocator>::size_type pos = 0,
@@ -608,10 +605,7 @@ public:
    // 23.3.5.1 constructors:
    /*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,
-                        _CharT __zero = _CharT('0'), _CharT __one = _CharT('1'));
+    explicit bitset(const char* __str);
    template<class _CharT, class _Traits, class _Allocator>
        explicit bitset(const basic_string<_CharT,_Traits,_Allocator>& __str,
                        typename basic_string<_CharT,_Traits,_Allocator>::size_type __pos = 0,
@@ -669,14 +663,11 @@ private:
 };

 template <size_t _Size>
-template<class _CharT>
-bitset<_Size>::bitset(const _CharT* __str,
-                      typename basic_string<_CharT>::size_type __n,
-                      _CharT __zero, _CharT __one)
+bitset<_Size>::bitset(const char* __str)
 {
-    size_t __rlen = _STD::min(__n, char_traits<_CharT>::length(__str));
+    size_t __rlen = strlen(__str);
    for (size_t __i = 0; __i < __rlen; ++__i)
-        if (__str[__i] != __zero && __str[__i] != __one)
+        if (__str[__i] != '0' && __str[__i] != '1')
 #ifndef _LIBCPP_NO_EXCEPTIONS
            throw invalid_argument("bitset string ctor has invalid argument");
 #else
@@ -686,11 +677,15 @@ bitset<_Size>::bitset(const _CharT* __str,
    size_t __i = 0;
    for (; __i < _M; ++__i)
    {
-        _CharT __c = __str[_M - 1 - __i];
-        if (__c == __zero)
+        switch (__str[_M - 1 - __i])
+        {
+        case '0':
            (*this)[__i] = false;
-        else
+            break;
+        case '1':
            (*this)[__i] = true;
+            break;
+        }
    }
    _STD::fill(base::__make_iter(__i), base::__make_iter(_Size), false);
 }
--- a/include/cassert
+++ b/include/cassert
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/ccomplex
+++ b/include/ccomplex
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cctype
+++ b/include/cctype
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cerrno
+++ b/include/cerrno
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cfenv
+++ b/include/cfenv
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cfloat
+++ b/include/cfloat
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/chrono
+++ b/include/chrono
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -223,26 +223,26 @@ public:
    typedef duration::rep                    rep;
    typedef duration::period                 period;
    typedef chrono::time_point<system_clock> time_point;
-    static const bool is_steady =            false;
+    static const bool is_monotonic =          false;

    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
+class monotonic_clock
 {
 public:
    typedef nanoseconds                                   duration;
    typedef duration::rep                                 rep;
    typedef duration::period                              period;
-    typedef chrono::time_point<steady_clock, duration>    time_point;
-    static const bool is_steady =                         true;
+    typedef chrono::time_point<monotonic_clock, duration> time_point;
+    static const bool is_monotonic =                       true;

    static time_point now();
 };

-typedef steady_clock high_resolution_clock;
+typedef monotonic_clock high_resolution_clock;

 }  // chrono

@@ -843,26 +843,26 @@ public:
    typedef duration::rep                    rep;
    typedef duration::period                 period;
    typedef chrono::time_point<system_clock> time_point;
-    static const bool is_steady =            false;
+    static const bool is_monotonic =          false;

    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
+class _LIBCPP_VISIBLE monotonic_clock
 {
 public:
    typedef nanoseconds                                   duration;
    typedef duration::rep                                 rep;
    typedef duration::period                              period;
-    typedef chrono::time_point<steady_clock, duration>    time_point;
-    static const bool is_steady =                         true;
+    typedef chrono::time_point<monotonic_clock, duration> time_point;
+    static const bool is_monotonic =                       true;

    static time_point now();
 };

-typedef steady_clock high_resolution_clock;
+typedef monotonic_clock high_resolution_clock;

 } // chrono

--- a/include/ciso646
+++ b/include/ciso646
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/climits
+++ b/include/climits
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/clocale
+++ b/include/clocale
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cmath
+++ b/include/cmath
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -297,6 +297,12 @@ long double    truncl(long double x);

 */

+// FIXME: work around for Clang with -std=C++0x on OSX/iOS
+#if defined(__clang__) && defined(__APPLE__)
+# pragma push_macro("__STRICT_ANSI__")
+# undef __STRICT_ANSI__
+#endif  // defined(__clang__) && defined(__APPLE__)
+
 #include <__config>
 #include <math.h>
 #include <type_traits>
@@ -1581,4 +1587,9 @@ using ::truncl;

 _LIBCPP_END_NAMESPACE_STD

+// FIXME: work around for Clang with -std=C++0x on OSX/iOS
+#if defined(__clang__) && defined(__APPLE__)
+# pragma pop_macro("__STRICT_ANSI__")
+#endif
+
 #endif  // _LIBCPP_CMATH
--- a/include/codecvt
+++ b/include/codecvt
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/complex
+++ b/include/complex
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -191,17 +191,17 @@ template<class T>              T norm(const complex<T>&);
 template<Integral T>      double norm(T);
                          float  norm(float);

-template<class T>      complex<T>           conj(const complex<T>&);
-                       complex<long double> conj(long double);
-                       complex<double>      conj(double);
-template<Integral T>   complex<double>      conj(T);
-                       complex<float>       conj(float);
+template<class T>      complex<T>  conj(const complex<T>&);
+                       long double conj(long double);
+                       double      conj(double);
+template<Integral T>   double      conj(T);
+                       float       conj(float);

-template<class T>    complex<T>           proj(const complex<T>&);
-                     complex<long double> proj(long double);
-                     complex<double>      proj(double);
-template<Integral T> complex<double>      proj(T);
-                     complex<float>       proj(float);
+template<class T>    complex<T>  proj(const complex<T>&);
+                     long double proj(long double);
+                     double      proj(double);
+template<Integral T> double      proj(T);
+                     float       proj(float);

 template<class T> complex<T> polar(const T&, const T& = 0);

@@ -980,17 +980,17 @@ conj(const complex<_Tp>& __c)
 }

 inline _LIBCPP_INLINE_VISIBILITY
-complex<long double>
+long double
 conj(long double __re)
 {
-    return complex<long double>(__re);
+    return __re;
 }

 inline _LIBCPP_INLINE_VISIBILITY
-complex<double>
+double
 conj(double __re)
 {
-    return complex<double>(__re);
+    return __re;
 }

 template<class _Tp>
@@ -998,18 +998,18 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
    is_integral<_Tp>::value,
-    complex<double>
+    double
 >::type
 conj(_Tp __re)
 {
-    return complex<double>(__re);
+    return __re;
 }

 inline _LIBCPP_INLINE_VISIBILITY
-complex<float>
+float
 conj(float __re)
 {
-    return complex<float>(__re);
+    return __re;
 }

 // proj
@@ -1026,21 +1026,21 @@ proj(const complex<_Tp>& __c)
 }

 inline _LIBCPP_INLINE_VISIBILITY
-complex<long double>
+long double
 proj(long double __re)
 {
    if (isinf(__re))
        __re = abs(__re);
-    return complex<long double>(__re);
+    return __re;
 }

 inline _LIBCPP_INLINE_VISIBILITY
-complex<double>
+double
 proj(double __re)
 {
    if (isinf(__re))
        __re = abs(__re);
-    return complex<double>(__re);
+    return __re;
 }

 template<class _Tp>
@@ -1048,20 +1048,20 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename enable_if
 <
    is_integral<_Tp>::value,
-    complex<double>
+    double
 >::type
 proj(_Tp __re)
 {
-    return complex<double>(__re);
+    return __re;
 }

 inline _LIBCPP_INLINE_VISIBILITY
-complex<float>
+float
 proj(float __re)
 {
    if (isinf(__re))
        __re = abs(__re);
-    return complex<float>(__re);
+    return __re;
 }

 // polar
--- a/include/complex.h
+++ b/include/complex.h
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/condition_variable
+++ b/include/condition_variable
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -232,7 +232,7 @@ cv_status
 condition_variable_any::wait_for(_Lock& __lock,
                                 const chrono::duration<_Rep, _Period>& __d)
 {
-    return wait_until(__lock, chrono::steady_clock::now() + __d);
+    return wait_until(__lock, chrono::monotonic_clock::now() + __d);
 }

 template <class _Lock, class _Rep, class _Period, class _Predicate>
@@ -242,7 +242,7 @@ condition_variable_any::wait_for(_Lock& __lock,
                                 const chrono::duration<_Rep, _Period>& __d,
                                 _Predicate __pred)
 {
-    return wait_until(__lock, chrono::steady_clock::now() + __d,
+    return wait_until(__lock, chrono::monotonic_clock::now() + __d,
                      _STD::move(__pred));
 }

--- a/include/csetjmp
+++ b/include/csetjmp
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/csignal
+++ b/include/csignal
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cstdarg
+++ b/include/cstdarg
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cstdbool
+++ b/include/cstdbool
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cstddef
+++ b/include/cstddef
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -78,6 +78,42 @@ struct _LIBCPP_VISIBLE nullptr_t
    friend _LIBCPP_ALWAYS_INLINE bool operator<=(nullptr_t, nullptr_t) {return true;}
    friend _LIBCPP_ALWAYS_INLINE bool operator>(nullptr_t, nullptr_t) {return false;}
    friend _LIBCPP_ALWAYS_INLINE bool operator>=(nullptr_t, nullptr_t) {return true;}
+
+    template <typename _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator==(nullptr_t, _Tp* __p) {return 0 == __p;}
+
+    template <typename _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator==(_Tp* __p, nullptr_t) {return __p == 0;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator!=(nullptr_t, _Tp* __p) {return 0 != __p;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator!=(_Tp* __p, nullptr_t) {return __p != 0;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator<(nullptr_t, _Tp* __p) {return 0 < __p;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator<(_Tp* __p, nullptr_t) {return __p < 0;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator<=(nullptr_t, _Tp* __p) {return 0 <= __p;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator<=(_Tp* __p, nullptr_t) {return __p <= 0;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator>(nullptr_t, _Tp* __p) {return 0 > __p;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator>(_Tp* __p, nullptr_t) {return __p > 0;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator>=(nullptr_t, _Tp* __p) {return 0 >= __p;}
+
+    template <class _Tp>
+        friend _LIBCPP_ALWAYS_INLINE bool operator>=(_Tp* __p, nullptr_t) {return __p >= 0;}
 };

 inline _LIBCPP_ALWAYS_INLINE nullptr_t __get_nullptr_t() {return nullptr_t(0);}
--- a/include/cstdint
+++ b/include/cstdint
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cstdio
+++ b/include/cstdio
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cstdlib
+++ b/include/cstdlib
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/ctgmath
+++ b/include/ctgmath
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/ctime
+++ b/include/ctime
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cwchar
+++ b/include/cwchar
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/cwctype
+++ b/include/cwctype
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/deque
+++ b/include/deque
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -603,7 +603,7 @@ copy_backward(_RAIter __f,
    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
    while (__f != __l)
    {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = prev(__r);
        pointer __rb = *__rp.__m_iter_;
        pointer __re = __rp.__ptr_ + 1;
        difference_type __bs = __re - __rb;
@@ -776,7 +776,7 @@ move_backward(_RAIter __f,
    typedef typename __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2>::pointer pointer;
    while (__f != __l)
    {
-        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = _STD::prev(__r);
+        __deque_iterator<_V2, _P2, _R2, _M2, _D2, _B2> __rp = prev(__r);
        pointer __rb = *__rp.__m_iter_;
        pointer __re = __rp.__ptr_ + 1;
        difference_type __bs = __re - __rb;
@@ -1116,7 +1116,7 @@ __deque_base<_Tp, _Allocator>::clear()
 {
    allocator_type& __a = __alloc();
    for (iterator __i = begin(), __e = end(); __i != __e; ++__i)
-        __alloc_traits::destroy(__a, _STD::addressof(*__i));
+        __alloc_traits::destroy(__a, addressof(*__i));
    size() = 0;
    while (__map_.size() > 2)
    {
@@ -1675,7 +1675,7 @@ deque<_Tp, _Allocator>::push_back(const value_type& __v)
    if (__back_spare() == 0)
        __add_back_capacity();
    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
+    __alloc_traits::construct(__a, addressof(*__base::end()), __v);
    ++__base::size();
 }

@@ -1689,7 +1689,7 @@ deque<_Tp, _Allocator>::push_back(value_type&& __v)
    if (__back_spare() == 0)
        __add_back_capacity();
    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
+    __alloc_traits::construct(__a, addressof(*__base::end()), _STD::move(__v));
    ++__base::size();
 }

@@ -1704,7 +1704,7 @@ deque<_Tp, _Allocator>::emplace_back(_Args&&... __args)
    if (__back_spare() == 0)
        __add_back_capacity();
    // __back_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, addressof(*__base::end()), _STD::forward<_Args>(__args)...);
    ++__base::size();
 }

@@ -1719,7 +1719,7 @@ deque<_Tp, _Allocator>::push_front(const value_type& __v)
    if (__front_spare() == 0)
        __add_front_capacity();
    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
+    __alloc_traits::construct(__a, addressof(*--__base::begin()), __v);
    --__base::__start_;
    ++__base::size();
 }
@@ -1734,7 +1734,7 @@ deque<_Tp, _Allocator>::push_front(value_type&& __v)
    if (__front_spare() == 0)
        __add_front_capacity();
    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
+    __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::move(__v));
    --__base::__start_;
    ++__base::size();
 }
@@ -1750,7 +1750,7 @@ deque<_Tp, _Allocator>::emplace_front(_Args&&... __args)
    if (__front_spare() == 0)
        __add_front_capacity();
    // __front_spare() >= 1
-    __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
+    __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
    --__base::__start_;
    ++__base::size();
 }
@@ -1772,7 +1772,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
        // __front_spare() >= 1
        if (__pos == 0)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), __v);
+            __alloc_traits::construct(__a, addressof(*--__base::begin()), __v);
            --__base::__start_;
            ++__base::size();
        }
@@ -1780,10 +1780,10 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
        {
            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
            iterator __b = __base::begin();
-            iterator __bm1 = _STD::prev(__b);
+            iterator __bm1 = prev(__b);
            if (__vt == pointer_traits<const_pointer>::pointer_to(*__b))
                __vt = pointer_traits<const_pointer>::pointer_to(*__bm1);
-            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
+            __alloc_traits::construct(__a, addressof(*__bm1), _STD::move(*__b));
            --__base::__start_;
            ++__base::size();
            if (__pos > 1)
@@ -1799,17 +1799,17 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, const value_type& __v)
        size_type __de = __base::size() - __pos;
        if (__de == 0)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), __v);
+            __alloc_traits::construct(__a, addressof(*__base::end()), __v);
            ++__base::size();
        }
        else
        {
            const_pointer __vt = pointer_traits<const_pointer>::pointer_to(__v);
            iterator __e = __base::end();
-            iterator __em1 = _STD::prev(__e);
+            iterator __em1 = prev(__e);
            if (__vt == pointer_traits<const_pointer>::pointer_to(*__em1))
                __vt = pointer_traits<const_pointer>::pointer_to(*__e);
-            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
+            __alloc_traits::construct(__a, addressof(*__e), _STD::move(*__em1));
            ++__base::size();
            if (__de > 1)
                __e = __move_backward_and_check(__e - __de, __em1, __e, __vt);
@@ -1835,15 +1835,15 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
        // __front_spare() >= 1
        if (__pos == 0)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::move(__v));
+            __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::move(__v));
            --__base::__start_;
            ++__base::size();
        }
        else
        {
            iterator __b = __base::begin();
-            iterator __bm1 = _STD::prev(__b);
-            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
+            iterator __bm1 = prev(__b);
+            __alloc_traits::construct(__a, addressof(*__bm1), _STD::move(*__b));
            --__base::__start_;
            ++__base::size();
            if (__pos > 1)
@@ -1859,14 +1859,14 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, value_type&& __v)
        size_type __de = __base::size() - __pos;
        if (__de == 0)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::move(__v));
+            __alloc_traits::construct(__a, addressof(*__base::end()), _STD::move(__v));
            ++__base::size();
        }
        else
        {
            iterator __e = __base::end();
-            iterator __em1 = _STD::prev(__e);
-            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
+            iterator __em1 = prev(__e);
+            __alloc_traits::construct(__a, addressof(*__e), _STD::move(*__em1));
            ++__base::size();
            if (__de > 1)
                __e = _STD::move_backward(__e - __de, __em1, __e);
@@ -1893,15 +1893,15 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
        // __front_spare() >= 1
        if (__pos == 0)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
+            __alloc_traits::construct(__a, addressof(*--__base::begin()), _STD::forward<_Args>(__args)...);
            --__base::__start_;
            ++__base::size();
        }
        else
        {
            iterator __b = __base::begin();
-            iterator __bm1 = _STD::prev(__b);
-            __alloc_traits::construct(__a, _STD::addressof(*__bm1), _STD::move(*__b));
+            iterator __bm1 = prev(__b);
+            __alloc_traits::construct(__a, addressof(*__bm1), _STD::move(*__b));
            --__base::__start_;
            ++__base::size();
            if (__pos > 1)
@@ -1917,14 +1917,14 @@ deque<_Tp, _Allocator>::emplace(const_iterator __p, _Args&&... __args)
        size_type __de = __base::size() - __pos;
        if (__de == 0)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*__base::end()), _STD::forward<_Args>(__args)...);
+            __alloc_traits::construct(__a, addressof(*__base::end()), _STD::forward<_Args>(__args)...);
            ++__base::size();
        }
        else
        {
            iterator __e = __base::end();
-            iterator __em1 = _STD::prev(__e);
-            __alloc_traits::construct(__a, _STD::addressof(*__e), _STD::move(*__em1));
+            iterator __em1 = prev(__e);
+            __alloc_traits::construct(__a, addressof(*__e), _STD::move(*__em1));
            ++__base::size();
            if (__de > 1)
                __e = _STD::move_backward(__e - __de, __em1, __e);
@@ -1955,7 +1955,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
        if (__n > __pos)
        {
            for (size_type __m = __n - __pos; __m; --__m, --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*--__i), __v);
+                __alloc_traits::construct(__a, addressof(*--__i), __v);
            __n = __pos;
        }
        if (__n > 0)
@@ -1981,7 +1981,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, size_type __n, const value_ty
        if (__n > __de)
        {
            for (size_type __m = __n - __de; __m; --__m, ++__i, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*__i), __v);
+                __alloc_traits::construct(__a, addressof(*__i), __v);
            __n = __de;
        }
        if (__n > 0)
@@ -2033,7 +2033,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
        {
            __m = __pos < __n / 2 ? _STD::prev(__l, __pos) : _STD::next(__f, __n - __pos);
            for (_BiIter __j = __m; __j != __f; --__base::__start_, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*--__i), *--__j);
+                __alloc_traits::construct(__a, addressof(*--__i), *--__j);
            __n = __pos;
        }
        if (__n > 0)
@@ -2041,7 +2041,7 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
            iterator __obn = __old_begin + __n;
            for (iterator __j = __obn; __j != __old_begin;)
            {
-                __alloc_traits::construct(__a, _STD::addressof(*--__i), _STD::move(*--__j));
+                __alloc_traits::construct(__a, addressof(*--__i), _STD::move(*--__j));
                --__base::__start_;
                ++__base::size();
            }
@@ -2065,14 +2065,14 @@ deque<_Tp, _Allocator>::insert(const_iterator __p, _BiIter __f, _BiIter __l,
        {
            __m = __de < __n / 2 ? _STD::next(__f, __de) : _STD::prev(__l, __n - __de);
            for (_BiIter __j = __m; __j != __l; ++__i, ++__j, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*__i), *__j);
+                __alloc_traits::construct(__a, addressof(*__i), *__j);
            __n = __de;
        }
        if (__n > 0)
        {
            iterator __oen = __old_end - __n;
            for (iterator __j = __oen; __j != __old_end; ++__i, ++__j, ++__base::size())
-                __alloc_traits::construct(__a, _STD::addressof(*__i), _STD::move(*__j));
+                __alloc_traits::construct(__a, addressof(*__i), _STD::move(*__j));
            if (__n < __de)
                __old_end = _STD::move_backward(__old_end - __de, __oen, __old_end);
            _STD::copy_backward(__f, __m, __old_end);
@@ -2105,7 +2105,7 @@ deque<_Tp, _Allocator>::__append(_ForIter __f, _ForIter __l,
        __add_back_capacity(__n - __back_capacity);
    // __n <= __back_capacity
    for (iterator __i = __base::end(); __f != __l; ++__i, ++__f, ++__base::size())
-        __alloc_traits::construct(__a, _STD::addressof(*__i), *__f);
+        __alloc_traits::construct(__a, addressof(*__i), *__f);
 }

 template <class _Tp, class _Allocator>
@@ -2118,7 +2118,7 @@ deque<_Tp, _Allocator>::__append(size_type __n)
        __add_back_capacity(__n - __back_capacity);
    // __n <= __back_capacity
    for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
-        __alloc_traits::construct(__a, _STD::addressof(*__i));
+        __alloc_traits::construct(__a, addressof(*__i));
 }

 template <class _Tp, class _Allocator>
@@ -2131,7 +2131,7 @@ deque<_Tp, _Allocator>::__append(size_type __n, const value_type& __v)
        __add_back_capacity(__n - __back_capacity);
    // __n <= __back_capacity
    for (iterator __i = __base::end(); __n; --__n, ++__i, ++__base::size())
-        __alloc_traits::construct(__a, _STD::addressof(*__i), __v);
+        __alloc_traits::construct(__a, addressof(*__i), __v);
 }

 // Create front capacity for one block of elements.
@@ -2209,7 +2209,7 @@ deque<_Tp, _Allocator>::__add_front_capacity(size_type __n)
    size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
    // Number of unused blocks at back:
    size_type __back_capacity = __back_spare() / __base::__block_size;
-    __back_capacity = _STD::min(__back_capacity, __nb);  // don't take more than you need
+    __back_capacity = min(__back_capacity, __nb);  // don't take more than you need
    __nb -= __back_capacity;  // number of blocks need to allocate
    // If __nb == 0, then we have sufficient capacity.
    if (__nb == 0)
@@ -2354,7 +2354,7 @@ deque<_Tp, _Allocator>::__add_back_capacity(size_type __n)
    size_type __nb = __recommend_blocks(__n + __base::__map_.empty());
    // Number of unused blocks at front:
    size_type __front_capacity = __front_spare() / __base::__block_size;
-    __front_capacity = _STD::min(__front_capacity, __nb);  // don't take more than you need
+    __front_capacity = min(__front_capacity, __nb);  // don't take more than you need
    __nb -= __front_capacity;  // number of blocks need to allocate
    // If __nb == 0, then we have sufficient capacity.
    if (__nb == 0)
@@ -2536,7 +2536,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
    allocator_type& __a = __base::__alloc();
    // as if
    //   for (; __f != __l; ++__r, ++__f, ++__base::size())
-    //       __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__f));
+    //       __alloc_traits::construct(__a, addressof(*__r), _STD::move(*__f));
    difference_type __n = __l - __f;
    while (__n > 0)
    {
@@ -2551,7 +2551,7 @@ deque<_Tp, _Allocator>::__move_construct_and_check(iterator __f, iterator __l,
        if (__fb <= __vt && __vt < __fe)
            __vt = (const_iterator(__f.__m_iter_, __vt) += __r - __f).__ptr_;
        for (; __fb != __fe; ++__fb, ++__r, ++__base::size())
-            __alloc_traits::construct(__a, _STD::addressof(*__r), _STD::move(*__fb));
+            __alloc_traits::construct(__a, addressof(*__r), _STD::move(*__fb));
        __n -= __bs;
        __f += __bs;
    }
@@ -2568,7 +2568,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
    // as if
    //   for (iterator __j = __l; __j != __f;)
    //   {
-    //       __alloc_traitsconstruct(__a, _STD::addressof(*--__r), _STD::move(*--__j));
+    //       __alloc_traitsconstruct(__a, addressof(*--__r), _STD::move(*--__j));
    //       --__base::__start_;
    //       ++__base::size();
    //   }
@@ -2588,7 +2588,7 @@ deque<_Tp, _Allocator>::__move_construct_backward_and_check(iterator __f, iterat
            __vt = (const_iterator(__l.__m_iter_, __vt) -= __l - __r + 1).__ptr_;
        while (__le != __lb)
        {
-            __alloc_traits::construct(__a, _STD::addressof(*--__r), _STD::move(*--__le));
+            __alloc_traits::construct(__a, addressof(*--__r), _STD::move(*--__le));
            --__base::__start_;
            ++__base::size();
        }
@@ -2608,8 +2608,8 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
    allocator_type& __a = __base::__alloc();
    if (__pos < (__base::size() - 1) / 2)
    {   // erase from front
-        _STD::move_backward(__b, __p, _STD::next(__p));
-        __alloc_traits::destroy(__a, _STD::addressof(*__b));
+        _STD::move_backward(__b, __p, next(__p));
+        __alloc_traits::destroy(__a, addressof(*__b));
        --__base::size();
        ++__base::__start_;
        if (__front_spare() >= 2 * __base::__block_size)
@@ -2622,7 +2622,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f)
    else
    {   // erase from back
        iterator __i = _STD::move(next(__p), __base::end(), __p);
-        __alloc_traits::destroy(__a, _STD::addressof(*__i));
+        __alloc_traits::destroy(__a, addressof(*__i));
        --__base::size();
        if (__back_spare() >= 2 * __base::__block_size)
        {
@@ -2648,7 +2648,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
        {   // erase from front
            iterator __i = _STD::move_backward(__b, __p, __p + __n);
            for (; __b != __i; ++__b)
-                __alloc_traits::destroy(__a, _STD::addressof(*__b));
+                __alloc_traits::destroy(__a, addressof(*__b));
            __base::size() -= __n;
            __base::__start_ += __n;
            while (__front_spare() >= 2 * __base::__block_size)
@@ -2662,7 +2662,7 @@ deque<_Tp, _Allocator>::erase(const_iterator __f, const_iterator __l)
        {   // erase from back
            iterator __i = _STD::move(__p + __n, __base::end(), __p);
            for (iterator __e = __base::end(); __i != __e; ++__i)
-                __alloc_traits::destroy(__a, _STD::addressof(*__i));
+                __alloc_traits::destroy(__a, addressof(*__i));
            __base::size() -= __n;
            while (__back_spare() >= 2 * __base::__block_size)
            {
@@ -2686,7 +2686,7 @@ deque<_Tp, _Allocator>::__erase_to_end(const_iterator __f)
        iterator __b = __base::begin();
        difference_type __pos = __f - __b;
        for (iterator __p = __b + __pos; __p != __e; ++__p)
-            __alloc_traits::destroy(__a, _STD::addressof(*__p));
+            __alloc_traits::destroy(__a, addressof(*__p));
        __base::size() -= __n;
        while (__back_spare() >= 2 * __base::__block_size)
        {
--- a/include/exception
+++ b/include/exception
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -40,12 +40,10 @@ public:

 typedef void (*unexpected_handler)();
 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 ) throw();
-terminate_handler get_terminate() throw();
 void terminate [[noreturn]] ();

 bool uncaught_exception() throw();
@@ -104,12 +102,10 @@ public:

 typedef void (*unexpected_handler)();
 _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) throw();
-_LIBCPP_VISIBLE terminate_handler get_terminate() throw();
 _LIBCPP_VISIBLE void terminate() __attribute__((__noreturn__));

 _LIBCPP_VISIBLE bool uncaught_exception() throw();
--- a/include/ext/hash_map
+++ b/include/ext/hash_map
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -341,9 +341,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -666,9 +666,9 @@ hash_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type& __k)
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return _STD::move(__h);
 }
--- a/include/ext/hash_set
+++ b/include/ext/hash_set
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/forward_list
+++ b/include/forward_list
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -106,21 +106,15 @@ public:
    void resize(size_type n, const value_type& v);
    void clear();

-    void splice_after(const_iterator p, forward_list& x);
    void splice_after(const_iterator p, forward_list&& x);
-    void splice_after(const_iterator p, forward_list& x, const_iterator i);
    void splice_after(const_iterator p, forward_list&& x, const_iterator i);
-    void splice_after(const_iterator p, forward_list& x,
-                      const_iterator first, const_iterator last);
    void splice_after(const_iterator p, forward_list&& x,
                      const_iterator first, const_iterator last);
    void remove(const value_type& v);
    template <class Predicate> void remove_if(Predicate pred);
    void unique();
    template <class BinaryPredicate> void unique(BinaryPredicate binary_pred);
-    void merge(forward_list& x);
    void merge(forward_list&& x);
-    template <class Compare> void merge(forward_list& x, Compare comp);
    template <class Compare> void merge(forward_list&& x, Compare comp);
    void sort();
    template <class Compare> void sort(Compare comp);
@@ -492,7 +486,7 @@ __forward_list_base<_Tp, _Alloc>::clear()
    for (__node_pointer __p = __before_begin()->__next_; __p != nullptr;)
    {
        __node_pointer __next = __p->__next_;
-        __node_traits::destroy(__a, _STD::addressof(__p->__value_));
+        __node_traits::destroy(__a, addressof(__p->__value_));
        __node_traits::deallocate(__a, __p, 1);
        __p = __next;
    }
@@ -638,18 +632,16 @@ public:
    void clear() {base::clear();}

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
    void splice_after(const_iterator __p, forward_list&& __x);
-    _LIBCPP_INLINE_VISIBILITY
    void splice_after(const_iterator __p, forward_list&& __x, const_iterator __i);
-    _LIBCPP_INLINE_VISIBILITY
    void splice_after(const_iterator __p, forward_list&& __x,
                      const_iterator __f, const_iterator __l);
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void splice_after(const_iterator __p, forward_list& __x);
    void splice_after(const_iterator __p, forward_list& __x, const_iterator __i);
    void splice_after(const_iterator __p, forward_list& __x,
                      const_iterator __f, const_iterator __l);
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void remove(const value_type& __v);
    template <class _Predicate> void remove_if(_Predicate __pred);
    _LIBCPP_INLINE_VISIBILITY
@@ -657,15 +649,13 @@ public:
    template <class _BinaryPredicate> void unique(_BinaryPredicate __binary_pred);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
-    void merge(forward_list&& __x) {merge(__x, __less<value_type>());}
-    template <class _Compare>
-        _LIBCPP_INLINE_VISIBILITY
-        void merge(forward_list&& __x, _Compare __comp)
-        {merge(__x, _STD::move(__comp));}
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    void merge(forward_list&& __x) {merge(_STD::move(__x), __less<value_type>());}
+    template <class _Compare> void merge(forward_list&& __x, _Compare __comp);
+#else  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    void merge(forward_list& __x) {merge(__x, __less<value_type>());}
    template <class _Compare> void merge(forward_list& __x, _Compare __comp);
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    void sort() {sort(__less<value_type>());}
    template <class _Compare> void sort(_Compare __comp);
@@ -712,7 +702,7 @@ forward_list<_Tp, _Alloc>::forward_list(size_type __n)
                                                             __p = __p->__next_)
        {
            __h.reset(__node_traits::allocate(__a, 1));
-            __node_traits::construct(__a, _STD::addressof(__h->__value_));
+            __node_traits::construct(__a, addressof(__h->__value_));
            __h->__next_ = nullptr;
            __p->__next_ = __h.release();
        }
@@ -871,7 +861,7 @@ typename enable_if
 forward_list<_Tp, _Alloc>::assign(_InputIterator __f, _InputIterator __l)
 {
    iterator __i = before_begin();
-    iterator __j = _STD::next(__i);
+    iterator __j = next(__i);
    iterator __e = end();
    for (; __j != __e && __f != __l; ++__i, ++__j, ++__f)
        *__j = *__f;
@@ -886,7 +876,7 @@ void
 forward_list<_Tp, _Alloc>::assign(size_type __n, const value_type& __v)
 {
    iterator __i = before_begin();
-    iterator __j = _STD::next(__i);
+    iterator __j = next(__i);
    iterator __e = end();
    for (; __j != __e && __n > 0; --__n, ++__i, ++__j)
        *__j = __v;
@@ -915,7 +905,7 @@ forward_list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_),
+    __node_traits::construct(__a, addressof(__h->__value_),
                                  _STD::forward<_Args>(__args)...);
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
@@ -930,7 +920,7 @@ forward_list<_Tp, _Alloc>::push_front(value_type&& __v)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__a, addressof(__h->__value_), _STD::move(__v));
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -944,7 +934,7 @@ forward_list<_Tp, _Alloc>::push_front(const value_type& __v)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__a, addressof(__h->__value_), __v);
    __h->__next_ = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __h.release();
 }
@@ -956,7 +946,7 @@ forward_list<_Tp, _Alloc>::pop_front()
    __node_allocator& __a = base::__alloc();
    __node_pointer __p = base::__before_begin()->__next_;
    base::__before_begin()->__next_ = __p->__next_;
-    __node_traits::destroy(__a, _STD::addressof(__p->__value_));
+    __node_traits::destroy(__a, addressof(__p->__value_));
    __node_traits::deallocate(__a, __p, 1);
 }

@@ -972,7 +962,7 @@ forward_list<_Tp, _Alloc>::emplace_after(const_iterator __p, _Args&&... __args)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_),
+    __node_traits::construct(__a, addressof(__h->__value_),
                                  _STD::forward<_Args>(__args)...);
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
@@ -989,7 +979,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, value_type&& __v)
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), _STD::move(__v));
+    __node_traits::construct(__a, addressof(__h->__value_), _STD::move(__v));
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -1005,7 +995,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, const value_type& __
    __node_allocator& __a = base::__alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-    __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+    __node_traits::construct(__a, addressof(__h->__value_), __v);
    __h->__next_ = __r->__next_;
    __r->__next_ = __h.release();
    return iterator(__r->__next_);
@@ -1022,7 +1012,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
        __node_allocator& __a = base::__alloc();
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-        __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+        __node_traits::construct(__a, addressof(__h->__value_), __v);
        __node_pointer __first = __h.release();
        __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1032,7 +1022,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
            for (--__n; __n != 0; --__n, __last = __last->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+                __node_traits::construct(__a, addressof(__h->__value_), __v);
                __last->__next_ = __h.release();
            }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1042,7 +1032,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p, size_type __n,
            while (__first != nullptr)
            {
                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
+                __node_traits::destroy(__a, addressof(__first->__value_));
                __node_traits::deallocate(__a, __first, 1);
                __first = __next;
            }
@@ -1072,7 +1062,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
        __node_allocator& __a = base::__alloc();
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __h(__node_traits::allocate(__a, 1), _D(__a, 1));
-        __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
+        __node_traits::construct(__a, addressof(__h->__value_), *__f);
        __node_pointer __first = __h.release();
        __node_pointer __last = __first;
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1082,7 +1072,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
            for (++__f; __f != __l; ++__f, __last = __last->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_), *__f);
+                __node_traits::construct(__a, addressof(__h->__value_), *__f);
                __last->__next_ = __h.release();
            }
 #ifndef _LIBCPP_NO_EXCEPTIONS
@@ -1092,7 +1082,7 @@ forward_list<_Tp, _Alloc>::insert_after(const_iterator __p,
            while (__first != nullptr)
            {
                __node_pointer __next = __first->__next_;
-                __node_traits::destroy(__a, _STD::addressof(__first->__value_));
+                __node_traits::destroy(__a, addressof(__first->__value_));
                __node_traits::deallocate(__a, __first, 1);
                __first = __next;
            }
@@ -1114,7 +1104,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f)
    __node_pointer __n = __p->__next_;
    __p->__next_ = __n->__next_;
    __node_allocator& __a = base::__alloc();
-    __node_traits::destroy(__a, _STD::addressof(__n->__value_));
+    __node_traits::destroy(__a, addressof(__n->__value_));
    __node_traits::deallocate(__a, __n, 1);
    return iterator(__p->__next_);
 }
@@ -1135,7 +1125,7 @@ forward_list<_Tp, _Alloc>::erase_after(const_iterator __f, const_iterator __l)
            do
            {
                __p = __n->__next_;
-                __node_traits::destroy(__a, _STD::addressof(__n->__value_));
+                __node_traits::destroy(__a, addressof(__n->__value_));
                __node_traits::deallocate(__a, __n, 1);
                __n = __p;
            } while (__n != __e);
@@ -1168,7 +1158,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n)
                                                         __ptr = __ptr->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_));
+                __node_traits::construct(__a, addressof(__h->__value_));
                __h->__next_ = nullptr;
                __ptr->__next_ = __h.release();
            }
@@ -1200,7 +1190,7 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
                                                         __ptr = __ptr->__next_)
            {
                __h.reset(__node_traits::allocate(__a, 1));
-                __node_traits::construct(__a, _STD::addressof(__h->__value_), __v);
+                __node_traits::construct(__a, addressof(__h->__value_), __v);
                __h->__next_ = nullptr;
                __ptr->__next_ = __h.release();
            }
@@ -1211,7 +1201,11 @@ forward_list<_Tp, _Alloc>::resize(size_type __n, const value_type& __v)
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+                                        forward_list&& __x)
+#else
                                        forward_list& __x)
+#endif
 {
    if (!__x.empty())
    {
@@ -1232,10 +1226,14 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+                                        forward_list&& __x,
+#else
                                        forward_list& __x,
+#endif
                                        const_iterator __i)
 {
-    const_iterator __lm1 = _STD::next(__i);
+    const_iterator __lm1 = next(__i);
    if (__p != __i && __p != __lm1)
    {
        const_cast<__node_pointer>(__i.__ptr_)->__next_ =
@@ -1250,7 +1248,11 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+                                        forward_list&& __x,
+#else
                                        forward_list& __x,
+#endif
                                        const_iterator __f, const_iterator __l)
 {
    if (__f != __l && __p != __f)
@@ -1270,39 +1272,6 @@ forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
    }
 }

-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list&& __x)
-{
-    splice_after(__p, __x);
-}
-
-template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list&& __x,
-                                        const_iterator __i)
-{
-    splice_after(__p, __x, __i);
-}
-
-template <class _Tp, class _Alloc>
-inline _LIBCPP_INLINE_VISIBILITY
-void
-forward_list<_Tp, _Alloc>::splice_after(const_iterator __p,
-                                        forward_list&& __x,
-                                        const_iterator __f, const_iterator __l)
-{
-    splice_after(__p, __x, __f, __l);
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 template <class _Tp, class _Alloc>
 void
 forward_list<_Tp, _Alloc>::remove(const value_type& __v)
@@ -1312,7 +1281,7 @@ forward_list<_Tp, _Alloc>::remove(const value_type& __v)
    {
        if (__i.__ptr_->__next_->__value_ == __v)
        {
-            iterator __j = _STD::next(__i, 2);
+            iterator __j = next(__i, 2);
            for (; __j != __e && *__j == __v; ++__j)
                ;
            erase_after(__i, __j);
@@ -1335,7 +1304,7 @@ forward_list<_Tp, _Alloc>::remove_if(_Predicate __pred)
    {
        if (__pred(__i.__ptr_->__next_->__value_))
        {
-            iterator __j = _STD::next(__i, 2);
+            iterator __j = next(__i, 2);
            for (; __j != __e && __pred(*__j); ++__j)
                ;
            erase_after(__i, __j);
@@ -1355,7 +1324,7 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 {
    for (iterator __i = begin(), __e = end(); __i != __e;)
    {
-        iterator __j = _STD::next(__i);
+        iterator __j = next(__i);
        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
            ;
        if (__i.__ptr_->__next_ != __j.__ptr_)
@@ -1367,7 +1336,11 @@ forward_list<_Tp, _Alloc>::unique(_BinaryPredicate __binary_pred)
 template <class _Tp, class _Alloc>
 template <class _Compare>
 void
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+forward_list<_Tp, _Alloc>::merge(forward_list&& __x, _Compare __comp)
+#else
 forward_list<_Tp, _Alloc>::merge(forward_list& __x, _Compare __comp)
+#endif
 {
    if (this != &__x)
    {
@@ -1456,7 +1429,7 @@ forward_list<_Tp, _Alloc>::__sort(__node_pointer __f1, difference_type __sz,
    }
    difference_type __sz1 = __sz / 2;
    difference_type __sz2 = __sz - __sz1;
-    __node_pointer __t = _STD::next(iterator(__f1), __sz1 - 1).__ptr_;
+    __node_pointer __t = next(iterator(__f1), __sz1 - 1).__ptr_;
    __node_pointer __f2 = __t->__next_;
    __t->__next_ = nullptr;
    return __merge(__sort(__f1, __sz1, __comp),
--- a/include/fstream
+++ b/include/fstream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -579,7 +579,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
                this->setg(this->eback(),
                           this->eback() + __unget_sz,
                           this->eback() + __unget_sz + __nmemb);
-                __c = traits_type::to_int_type(*this->gptr());
+                __c = *this->gptr();
            }
        }
        else
@@ -587,7 +587,7 @@ basic_filebuf<_CharT, _Traits>::underflow()
            memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
            __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
            __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            size_t __nmemb = _STD::min(static_cast<size_t>(this->egptr() - this->eback() - __unget_sz),
+            size_t __nmemb = 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_;
@@ -602,18 +602,18 @@ basic_filebuf<_CharT, _Traits>::underflow()
                if (__r == codecvt_base::noconv)
                {
                    this->setg((char_type*)__extbuf_, (char_type*)__extbuf_, (char_type*)__extbufend_);
-                    __c = traits_type::to_int_type(*this->gptr());
+                    __c = *this->gptr();
                }
                else if (__inext != this->eback() + __unget_sz)
                {
                    this->setg(this->eback(), this->eback() + __unget_sz, __inext);
-                    __c = traits_type::to_int_type(*this->gptr());
+                    __c = *this->gptr();
                }
            }
        }
    }
    else
-        __c = traits_type::to_int_type(*this->gptr());
+        __c = *this->gptr();
    if (this->eback() == &__1buf)
        this->setg(0, 0, 0);
    return __c;
--- a/include/functional
+++ b/include/functional
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -1559,7 +1559,10 @@ typename enable_if
 __mu(_Ti&, _Uj& __uj)
 {
    const size_t _Indx = is_placeholder<_Ti>::value - 1;
-    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
+    // compiler bug workaround
+    typename tuple_element<_Indx, _Uj>::type __t = get<_Indx>(__uj);
+    return __t;
+//    return _STD::forward<typename tuple_element<_Indx, _Uj>::type>(get<_Indx>(__uj));
 }

 template <class _Ti, class _Uj>
--- a/include/future
+++ b/include/future
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -27,9 +27,9 @@ enum class future_errc

 enum class launch
 {
-    async = 1,
-    deferred = 2,
-    any = async | deferred
+    any,
+    async,
+    sync
 };

 enum class future_status
@@ -156,7 +156,6 @@ public:
    ~future();
    future& operator=(const future& rhs) = delete;
    future& operator=(future&&);
-    shared_future<R> share() &&;

    // retrieving the value
    R get();
@@ -183,7 +182,6 @@ public:
    ~future();
    future& operator=(const future& rhs) = delete;
    future& operator=(future&&);
-    shared_future<R&> share() &&;

    // retrieving the value
    R& get();
@@ -210,7 +208,6 @@ public:
    ~future();
    future& operator=(const future& rhs) = delete;
    future& operator=(future&&);
-    shared_future<void> share() &&;

    // retrieving the value
    void get();
@@ -308,6 +305,81 @@ public:
        wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
 };

+template <class R>
+class atomic_future
+{
+public:
+    atomic_future();
+    atomic_future(const atomic_future& rhs);
+    atomic_future(future<R>&&);
+    ~atomic_future();
+    atomic_future& operator=(const atomic_future& rhs);
+
+    // retrieving the value
+    const R& get() const;
+
+    // functions to check state
+    bool valid() const;
+
+    void wait() const;
+    template <class Rep, class Period>
+        future_status
+        wait_for(const chrono::duration<Rep, Period>& rel_time) const;
+    template <class Clock, class Duration>
+        future_status
+        wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+};
+
+template <class R>
+class atomic_future<R&>
+{
+public:
+    atomic_future();
+    atomic_future(const atomic_future& rhs);
+    atomic_future(future<R>&&);
+    ~atomic_future();
+    atomic_future& operator=(const atomic_future& rhs);
+
+    // retrieving the value
+    R& get() const;
+
+    // functions to check state
+    bool valid() const;
+
+    void wait() const;
+    template <class Rep, class Period>
+        future_status
+        wait_for(const chrono::duration<Rep, Period>& rel_time) const;
+    template <class Clock, class Duration>
+        future_status
+        wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+};
+
+template <>
+class atomic_future<void>
+{
+public:
+    atomic_future();
+    atomic_future(const atomic_future& rhs);
+    atomic_future(future<R>&&);
+    ~atomic_future();
+    atomic_future& operator=(const atomic_future& rhs);
+
+    // retrieving the value
+    void get() const;
+
+    // functions to check state
+    bool valid() const;
+
+    void wait() const;
+    template <class Rep, class Period>
+        future_status
+        wait_for(const chrono::duration<Rep, Period>& rel_time) const;
+    template <class Clock, class Duration>
+        future_status
+        wait_until(const chrono::time_point<Clock, Duration>& abs_time) const;
+};
+
 template <class F, class... Args>
  future<typename result_of<F(Args...)>::type>
  async(F&& f, Args&&... args);
@@ -341,7 +413,7 @@ public:
    packaged_task& operator=(packaged_task&& other);
    void swap(packaged_task& other);

-    bool valid() const;
+    explicit operator bool() const;

    // result retrieval
    future<R> get_future();
@@ -398,9 +470,9 @@ struct _LIBCPP_VISIBLE is_error_code_enum<future_errc> : public true_type {};
 struct _LIBCPP_VISIBLE launch
 {
 enum _ {
-    async = 1,
-    deferred = 2,
-    any = async | deferred
+    any,
+    async,
+    sync
 };

    _ __v_;
@@ -531,7 +603,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 future_status
 __assoc_sub_state::wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
 {
-    return wait_until(chrono::steady_clock::now() + __rel_time);
+    return wait_until(chrono::monotonic_clock::now() + __rel_time);
 }

 template <class _R>
@@ -914,7 +986,6 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    ~future();
-    shared_future<_R> share();

    // retrieving the value
    _R get();
@@ -1012,7 +1083,6 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    ~future();
-    shared_future<_R&> share();

    // retrieving the value
    _R& get();
@@ -1105,7 +1175,6 @@ private:
 public:
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    ~future();
-    shared_future<void> share();

    // retrieving the value
    void get();
@@ -1824,7 +1893,8 @@ public:
    }

    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __p_.__state_ != nullptr;}
+    //explicit
+        operator bool() const {return __p_.__state_ != nullptr;}

    // result retrieval
    _LIBCPP_INLINE_VISIBILITY
@@ -1886,7 +1956,7 @@ void
 packaged_task<_R(_ArgTypes...)>::reset()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    if (!valid())
+    if (!(*this))
        throw future_error(make_error_code(future_errc::no_state));
 #endif  // _LIBCPP_NO_EXCEPTIONS
    __p_ = promise<result_type>();
@@ -1939,7 +2009,8 @@ public:
    }

    _LIBCPP_INLINE_VISIBILITY
-    bool valid() const {return __p_.__state_ != nullptr;}
+    //explicit
+        operator bool() const {return __p_.__state_ != nullptr;}

    // result retrieval
    _LIBCPP_INLINE_VISIBILITY
@@ -2003,7 +2074,7 @@ void
 packaged_task<void(_ArgTypes...)>::reset()
 {
 #ifndef _LIBCPP_NO_EXCEPTIONS
-    if (!valid())
+    if (!(*this))
        throw future_error(make_error_code(future_errc::no_state));
 #endif  // _LIBCPP_NO_EXCEPTIONS
    __p_ = promise<result_type>();
@@ -2040,16 +2111,16 @@ async(launch __policy, _F&& __f, _Args&&... __args)
 {
    typedef typename result_of<_F(_Args...)>::type _R;
    future<_R> __r;
-    if (__policy & launch::async)
+    if (__policy == launch::sync)
+        __r = _STD::__make_deferred_assoc_state<_R>(bind(_STD::forward<_F>(__f),
+                                               _STD::forward<_Args>(__args)...));
+    else
    {
        packaged_task<_R()> __pk(bind(_STD::forward<_F>(__f),
                                      _STD::forward<_Args>(__args)...));
        __r = __pk.get_future();
        thread(_STD::move(__pk)).detach();
    }
-    else if (__policy & launch::deferred)
-        __r = _STD::__make_deferred_assoc_state<_R>(bind(_STD::forward<_F>(__f),
-                                              _STD::forward<_Args>(__args)...));
    return __r;
 }

@@ -2281,32 +2352,223 @@ swap(shared_future<_R>& __x, shared_future<_R>& __y)
    __x.swap(__y);
 }

-template <class _R>
-inline _LIBCPP_INLINE_VISIBILITY
-shared_future<_R>
-future<_R>::share()
-{
-    return shared_future<_R>(_STD::move(*this));
-}
+// atomic_future

 template <class _R>
-inline _LIBCPP_INLINE_VISIBILITY
-shared_future<_R&>
-future<_R&>::share()
+class _LIBCPP_VISIBLE atomic_future
 {
-    return shared_future<_R&>(_STD::move(*this));
-}
+    __assoc_state<_R>* __state_;
+    mutable mutex __mut_;

+public:
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future() : __state_(nullptr) {}
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future(const atomic_future& __rhs) : __state_(__rhs.__state_)
+        {if (__state_) __state_->__add_shared();}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future(future<_R>&& __f) : __state_(__f.__state_)
+        {__f.__state_ = nullptr;}
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    ~atomic_future();
+    atomic_future& operator=(const atomic_future& __rhs);

-inline _LIBCPP_INLINE_VISIBILITY
-shared_future<void>
-future<void>::share()
+    // retrieving the value
+    _LIBCPP_INLINE_VISIBILITY
+    const _R& get() const {return __state_->copy();}
+
+    void swap(atomic_future& __rhs);
+
+    // functions to check state
+    _LIBCPP_INLINE_VISIBILITY
+    bool valid() const {return __state_ != nullptr;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void wait() const {__state_->wait();}
+    template <class _Rep, class _Period>
+        _LIBCPP_INLINE_VISIBILITY
+        future_status
+        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
+            {return __state_->wait_for(__rel_time);}
+    template <class _Clock, class _Duration>
+        _LIBCPP_INLINE_VISIBILITY
+        future_status
+        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
+            {return __state_->wait_until(__abs_time);}
+};
+
+template <class _R>
+atomic_future<_R>::~atomic_future()
 {
-    return shared_future<void>(_STD::move(*this));
+    if (__state_)
+        __state_->__release_shared();
 }

+template <class _R>
+atomic_future<_R>&
+atomic_future<_R>::operator=(const atomic_future& __rhs)
+{
+    if (this != &__rhs)
+    {
+        unique_lock<mutex> __this(__mut_, defer_lock);
+        unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
+        _STD::lock(__this, __that);
+        if (__rhs.__state_)
+            __rhs.__state_->__add_shared();
+        if (__state_)
+            __state_->__release_shared();
+        __state_ = __rhs.__state_;
+    }
+    return *this;
+}
+
+template <class _R>
+void
+atomic_future<_R>::swap(atomic_future& __rhs)
+{
+    if (this != &__rhs)
+    {
+        unique_lock<mutex> __this(__mut_, defer_lock);
+        unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
+        _STD::lock(__this, __that);
+        _STD::swap(__state_, __rhs.__state_);
+    }
+}
+
+template <class _R>
+class _LIBCPP_VISIBLE atomic_future<_R&>
+{
+    __assoc_state<_R&>* __state_;
+    mutable mutex __mut_;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future() : __state_(nullptr) {}
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future(const atomic_future& __rhs) : __state_(__rhs.__state_)
+        {if (__state_) __state_->__add_shared();}
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future(future<_R&>&& __f) : __state_(__f.__state_)
+        {__f.__state_ = nullptr;}
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    ~atomic_future();
+    atomic_future& operator=(const atomic_future& __rhs);
+
+    // retrieving the value
+    _LIBCPP_INLINE_VISIBILITY
+    _R& get() const {return __state_->copy();}
+
+    void swap(atomic_future& __rhs);
+
+    // functions to check state
+    _LIBCPP_INLINE_VISIBILITY
+    bool valid() const {return __state_ != nullptr;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void wait() const {__state_->wait();}
+    template <class _Rep, class _Period>
+        _LIBCPP_INLINE_VISIBILITY
+        future_status
+        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
+            {return __state_->wait_for(__rel_time);}
+    template <class _Clock, class _Duration>
+        _LIBCPP_INLINE_VISIBILITY
+        future_status
+        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
+            {return __state_->wait_until(__abs_time);}
+};
+
+template <class _R>
+atomic_future<_R&>::~atomic_future()
+{
+    if (__state_)
+        __state_->__release_shared();
+}
+
+template <class _R>
+atomic_future<_R&>&
+atomic_future<_R&>::operator=(const atomic_future& __rhs)
+{
+    if (this != &__rhs)
+    {
+        unique_lock<mutex> __this(__mut_, defer_lock);
+        unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
+        _STD::lock(__this, __that);
+        if (__rhs.__state_)
+            __rhs.__state_->__add_shared();
+        if (__state_)
+            __state_->__release_shared();
+        __state_ = __rhs.__state_;
+    }
+    return *this;
+}
+
+template <class _R>
+void
+atomic_future<_R&>::swap(atomic_future& __rhs)
+{
+    if (this != &__rhs)
+    {
+        unique_lock<mutex> __this(__mut_, defer_lock);
+        unique_lock<mutex> __that(__rhs.__mut_, defer_lock);
+        _STD::lock(__this, __that);
+        _STD::swap(__state_, __rhs.__state_);
+    }
+}
+
+template <>
+class _LIBCPP_VISIBLE atomic_future<void>
+{
+    __assoc_sub_state* __state_;
+    mutable mutex __mut_;
+
+public:
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future() : __state_(nullptr) {}
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future(const atomic_future& __rhs) : __state_(__rhs.__state_)
+        {if (__state_) __state_->__add_shared();}
+#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    _LIBCPP_INLINE_VISIBILITY
+    atomic_future(future<void>&& __f) : __state_(__f.__state_)
+        {__f.__state_ = nullptr;}
+#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
+    ~atomic_future();
+    atomic_future& operator=(const atomic_future& __rhs);
+
+    // retrieving the value
+    _LIBCPP_INLINE_VISIBILITY
+    void get() const {__state_->copy();}
+
+    void swap(atomic_future& __rhs);
+
+    // functions to check state
+    _LIBCPP_INLINE_VISIBILITY
+    bool valid() const {return __state_ != nullptr;}
+
+    _LIBCPP_INLINE_VISIBILITY
+    void wait() const {__state_->wait();}
+    template <class _Rep, class _Period>
+        _LIBCPP_INLINE_VISIBILITY
+        future_status
+        wait_for(const chrono::duration<_Rep, _Period>& __rel_time) const
+            {return __state_->wait_for(__rel_time);}
+    template <class _Clock, class _Duration>
+        _LIBCPP_INLINE_VISIBILITY
+        future_status
+        wait_until(const chrono::time_point<_Clock, _Duration>& __abs_time) const
+            {return __state_->wait_until(__abs_time);}
+};
+
+template <class _R>
+inline _LIBCPP_INLINE_VISIBILITY
+void
+swap(atomic_future<_R>& __x, atomic_future<_R>& __y)
+{
+    __x.swap(__y);
+}

 _LIBCPP_END_NAMESPACE_STD

--- a/include/initializer_list
+++ b/include/initializer_list
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/iomanip
+++ b/include/iomanip
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/ios
+++ b/include/ios
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -272,16 +272,16 @@ public:
    class Init;

    // 27.5.2.2 fmtflags state:
-    _LIBCPP_INLINE_VISIBILITY fmtflags flags() const;
-    _LIBCPP_INLINE_VISIBILITY fmtflags flags(fmtflags __fmtfl);
-    _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl);
-    _LIBCPP_INLINE_VISIBILITY fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
-    _LIBCPP_INLINE_VISIBILITY void unsetf(fmtflags __mask);
+    fmtflags flags() const;
+    fmtflags flags(fmtflags __fmtfl);
+    fmtflags setf(fmtflags __fmtfl);
+    fmtflags setf(fmtflags __fmtfl, fmtflags __mask);
+    void unsetf(fmtflags __mask);

-    _LIBCPP_INLINE_VISIBILITY streamsize precision() const;
-    _LIBCPP_INLINE_VISIBILITY streamsize precision(streamsize __prec);
-    _LIBCPP_INLINE_VISIBILITY streamsize width() const;
-    _LIBCPP_INLINE_VISIBILITY streamsize width(streamsize __wide);
+    streamsize precision() const;
+    streamsize precision(streamsize __prec);
+    streamsize width() const;
+    streamsize width(streamsize __wide);

    // 27.5.2.3 locales:
    locale imbue(const locale& __loc);
@@ -307,17 +307,17 @@ private:
 public:
    static bool sync_with_stdio(bool __sync = true);

-    _LIBCPP_INLINE_VISIBILITY iostate rdstate() const;
+    iostate rdstate() const;
    void clear(iostate __state = goodbit);
-    _LIBCPP_INLINE_VISIBILITY void setstate(iostate __state);
+    void setstate(iostate __state);

-    _LIBCPP_INLINE_VISIBILITY bool good() const;
-    _LIBCPP_INLINE_VISIBILITY bool eof() const;
-    _LIBCPP_INLINE_VISIBILITY bool fail() const;
-    _LIBCPP_INLINE_VISIBILITY bool bad() const;
+    bool good() const;
+    bool eof() const;
+    bool fail() const;
+    bool bad() const;

-    _LIBCPP_INLINE_VISIBILITY iostate exceptions() const;
-    _LIBCPP_INLINE_VISIBILITY void exceptions(iostate __except);
+    iostate exceptions() const;
+    void exceptions(iostate __except);

    void __set_badbit_and_consider_rethrow();
    void __set_failbit_and_consider_rethrow();
@@ -587,52 +587,38 @@ public:
    _LIBCPP_ALWAYS_INLINE void exceptions(iostate __except) {ios_base::exceptions(__except);}

    // 27.5.4.1 Constructor/destructor:
-    _LIBCPP_INLINE_VISIBILITY
    explicit basic_ios(basic_streambuf<char_type,traits_type>* __sb);
    virtual ~basic_ios();

    // 27.5.4.2 Members:
-    _LIBCPP_INLINE_VISIBILITY 
    basic_ostream<char_type, traits_type>* tie() const;
-    _LIBCPP_INLINE_VISIBILITY 
    basic_ostream<char_type, traits_type>* tie(basic_ostream<char_type, traits_type>* __tiestr);

-    _LIBCPP_INLINE_VISIBILITY 
    basic_streambuf<char_type, traits_type>* rdbuf() const;
-    _LIBCPP_INLINE_VISIBILITY 
    basic_streambuf<char_type, traits_type>* rdbuf(basic_streambuf<char_type, traits_type>* __sb);

    basic_ios& copyfmt(const basic_ios& __rhs);

-    _LIBCPP_INLINE_VISIBILITY 
    char_type fill() const;
-    _LIBCPP_INLINE_VISIBILITY 
    char_type fill(char_type __ch);

-    _LIBCPP_INLINE_VISIBILITY 
    locale imbue(const locale& __loc);

-    _LIBCPP_INLINE_VISIBILITY 
    char narrow(char_type __c, char __dfault) const;
-    _LIBCPP_INLINE_VISIBILITY 
    char_type widen(char __c) const;

 protected:
    _LIBCPP_ALWAYS_INLINE
    basic_ios() {// purposefully does no initialization
                }
-    _LIBCPP_INLINE_VISIBILITY 
    void init(basic_streambuf<char_type, traits_type>* __sb);

-    _LIBCPP_INLINE_VISIBILITY 
    void move(basic_ios& __rhs);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_ALWAYS_INLINE
    void move(basic_ios&& __rhs) {move(__rhs);}
 #endif
-    _LIBCPP_INLINE_VISIBILITY 
    void swap(basic_ios& __rhs);
-    _LIBCPP_INLINE_VISIBILITY 
    void set_rdbuf(basic_streambuf<char_type, traits_type>* __sb);
 private:
    basic_ostream<char_type, traits_type>* __tie_;
--- a/include/iosfwd
+++ b/include/iosfwd
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -92,8 +92,6 @@ typedef fpos<char_traits<wchar_t>::state_type> wstreampos;

 _LIBCPP_BEGIN_NAMESPACE_STD

-class ios_base;
-
 template<class _CharT>  struct _LIBCPP_VISIBLE char_traits;
 template<class _Tp>     class _LIBCPP_VISIBLE allocator;

--- a/include/iostream
+++ b/include/iostream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/istream
+++ b/include/istream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -801,13 +801,6 @@ 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;
@@ -819,7 +812,6 @@ operator>>(basic_istream<_CharT, _Traits>& __is, _CharT& __c)
            }
            else
                __is.setstate(ios_base::eofbit | ios_base::failbit);
-#endif
        }
 #ifndef _LIBCPP_NO_EXCEPTIONS
    }
@@ -1273,7 +1265,7 @@ basic_istream<_CharT, _Traits>::readsome(char_type* __s, streamsize __n)
            case 0:
                break;
            default:
-                __c = _STD::min(__c, __n);
+                __c = min(__c, __n);
                for (streamsize __k = 0; __k < __c; ++__k, ++__s, ++__i)
                    *__s = *__i;
            }
--- a/include/iterator
+++ b/include/iterator
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -488,7 +488,7 @@ next(_ForwardIter __x,
     typename iterator_traits<_ForwardIter>::difference_type __n = 1,
     typename enable_if<__is_forward_iterator<_ForwardIter>::value>::type* = 0)
 {
-    _STD::advance(__x, __n);
+    advance(__x, __n);
    return __x;
 }

@@ -499,7 +499,7 @@ prev(_BidiretionalIter __x,
     typename iterator_traits<_BidiretionalIter>::difference_type __n = 1,
     typename enable_if<__is_bidirectional_iterator<_BidiretionalIter>::value>::type* = 0)
 {
-    _STD::advance(__x, -__n);
+    advance(__x, -__n);
    return __x;
 }

@@ -902,13 +902,8 @@ public:
    template <class _Up> _LIBCPP_INLINE_VISIBILITY move_iterator(const move_iterator<_Up>& __u)
        : __i(__u.base()) {}
    _LIBCPP_INLINE_VISIBILITY _Iter base() const {return __i;}
-    _LIBCPP_INLINE_VISIBILITY reference operator*() const {
-      return static_cast<reference>(*__i);
-    }
-    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {
-      typename iterator_traits<iterator_type>::reference __ref = *__i;
-      return &__ref;
-    }
+    _LIBCPP_INLINE_VISIBILITY reference operator*() const {return *__i;}
+    _LIBCPP_INLINE_VISIBILITY pointer  operator->() const {return &(operator*());}
    _LIBCPP_INLINE_VISIBILITY move_iterator& operator++() {++__i; return *this;}
    _LIBCPP_INLINE_VISIBILITY move_iterator  operator++(int)
        {move_iterator __tmp(*this); ++__i; return __tmp;}
@@ -924,9 +919,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY move_iterator& operator-=(difference_type __n)
        {__i -= __n; return *this;}
    _LIBCPP_INLINE_VISIBILITY reference         operator[](difference_type __n) const
-    {
-      return static_cast<reference>(__i[__n]);
-    }
+        {return __i[__n];}
 };

 template <class _Iter1, class _Iter2>
@@ -1045,7 +1038,7 @@ template <class _B1, class _B2> _B2 move_backward(_B1, _B1, _B2);
 template <class _Tp>
 typename enable_if
 <
-    is_trivially_copy_assignable<_Tp>::value,
+    has_trivial_copy_assign<_Tp>::value,
    _Tp*
 >::type
 __unwrap_iter(__wrap_iter<_Tp*>);
@@ -1144,7 +1137,7 @@ private:
    friend
    typename enable_if
    <
-        is_trivially_copy_assignable<_Tp>::value,
+        has_trivial_copy_assign<_Tp>::value,
        _Tp*
    >::type
    __unwrap_iter(__wrap_iter<_Tp*>);
@@ -1623,7 +1616,7 @@ operator+(typename __debug_iter<_Container, _Iter>::difference_type __n,

 #endif  // _LIBCPP_DEBUG

-#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DECLTYPE)

 template <class _C>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1657,7 +1650,7 @@ end(const _C& __c) -> decltype(__c.end())
    return __c.end();
 }

-#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#else  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DECLTYPE)

 template <class _C>
 inline _LIBCPP_INLINE_VISIBILITY
@@ -1691,7 +1684,7 @@ end(const _C& __c)
    return __c.end();
 }

-#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_TRAILING_RETURN)
+#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_DECLTYPE)

 template <class _T, size_t _N>
 inline _LIBCPP_INLINE_VISIBILITY
--- a/include/limits
+++ b/include/limits
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/list
+++ b/include/list
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -236,8 +236,6 @@ public:
                                             pointer;
    typedef typename pointer_traits<pointer>::difference_type difference_type;

-    _LIBCPP_INLINE_VISIBILITY
-    __list_iterator() {}
    _LIBCPP_INLINE_VISIBILITY
    reference operator*() const {return __ptr_->__value_;}
    _LIBCPP_INLINE_VISIBILITY
@@ -291,8 +289,6 @@ public:
                                             pointer;
    typedef typename pointer_traits<pointer>::difference_type difference_type;

-    _LIBCPP_INLINE_VISIBILITY
-    __list_const_iterator() {}
    _LIBCPP_INLINE_VISIBILITY
    __list_const_iterator(__list_iterator<_Tp, _VoidPtr> __p) : __ptr_(__p.__ptr_) {}

@@ -473,8 +469,8 @@ __list_imp<_Tp, _Alloc>::clear()
        {
            __node& __n = *__f.__ptr_;
            ++__f;
-            __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-            __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+            __node_alloc_traits::destroy(__na, addressof(__n.__value_));
+            __node_alloc_traits::deallocate(__na, addressof(__n), 1);
        }
    }
 }
@@ -714,8 +710,8 @@ inline _LIBCPP_INLINE_VISIBILITY
 typename list<_Tp, _Alloc>::iterator
 list<_Tp, _Alloc>::__iterator(size_type __n)
 {
-    return __n <= base::__sz() / 2 ? _STD::next(begin(), __n)
-                                   : _STD::prev(end(), base::__sz() - __n);
+    return __n <= base::__sz() / 2 ? next(begin(), __n)
+                                   : prev(end(), base::__sz() - __n);
 }

 template <class _Tp, class _Alloc>
@@ -915,7 +911,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, const value_type& __x)
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
    __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
    __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
    ++base::__sz();
    return iterator(__hold.release());
@@ -933,7 +929,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+        __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
        ++__ds;
        __r = iterator(__hold.get());
        __hold.release();
@@ -945,7 +941,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
            for (--__n; __n != 0; --__n, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+                __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -956,7 +952,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, size_type __n, const value_type& _
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -986,7 +982,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), *__f);
+        __node_alloc_traits::construct(__na, addressof(__hold->__value_), *__f);
        ++__ds;
        __r = iterator(__hold.get());
        __hold.release();
@@ -998,7 +994,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
            for (++__f; __f != __l; ++__f, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), *__f);
+                __node_alloc_traits::construct(__na, addressof(__hold->__value_), *__f);
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -1009,7 +1005,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, _InpIter __f, _InpIter __l,
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -1032,7 +1028,7 @@ list<_Tp, _Alloc>::push_front(const value_type& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
    __link_nodes(*base::__end_.__next_, *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1045,7 +1041,7 @@ list<_Tp, _Alloc>::push_back(const value_type& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
    __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1060,7 +1056,7 @@ list<_Tp, _Alloc>::push_front(value_type&& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::move(__x));
    __link_nodes(*base::__end_.__next_, *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1073,7 +1069,7 @@ list<_Tp, _Alloc>::push_back(value_type&& __x)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::move(__x));
    __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1089,7 +1085,7 @@ list<_Tp, _Alloc>::emplace_front(_Args&&... __args)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
    __link_nodes(*base::__end_.__next_, *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1103,7 +1099,7 @@ list<_Tp, _Alloc>::emplace_back(_Args&&... __args)
    __node_allocator& __na = base::__node_alloc();
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
    __link_nodes(static_cast<__node&>(base::__end_), *__hold, *__hold);
    ++base::__sz();
    __hold.release();
@@ -1118,7 +1114,7 @@ list<_Tp, _Alloc>::emplace(const_iterator __p, _Args&&... __args)
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
    __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::forward<_Args>(__args)...);
    __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
    ++base::__sz();
    return iterator(__hold.release());
@@ -1134,7 +1130,7 @@ list<_Tp, _Alloc>::insert(const_iterator __p, value_type&& __x)
    typedef __allocator_destructor<__node_allocator> _D;
    unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
    __hold->__prev_ = 0;
-    __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), _STD::move(__x));
+    __node_alloc_traits::construct(__na, addressof(__hold->__value_), _STD::move(__x));
    __link_nodes(const_cast<__node&>(*__p.__ptr_), *__hold, *__hold);
    ++base::__sz();
    return iterator(__hold.release());
@@ -1150,8 +1146,8 @@ list<_Tp, _Alloc>::pop_front()
    __node& __n = *base::__end_.__next_;
    base::__unlink_nodes(__n, __n);
    --base::__sz();
-    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, addressof(__n), 1);
 }

 template <class _Tp, class _Alloc>
@@ -1162,8 +1158,8 @@ list<_Tp, _Alloc>::pop_back()
    __node& __n = *base::__end_.__prev_;
    base::__unlink_nodes(__n, __n);
    --base::__sz();
-    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, addressof(__n), 1);
 }

 template <class _Tp, class _Alloc>
@@ -1175,8 +1171,8 @@ list<_Tp, _Alloc>::erase(const_iterator __p)
    __node_pointer __r = __n.__next_;
    base::__unlink_nodes(__n, __n);
    --base::__sz();
-    __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-    __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+    __node_alloc_traits::destroy(__na, addressof(__n.__value_));
+    __node_alloc_traits::deallocate(__na, addressof(__n), 1);
    return iterator(__r);
 }

@@ -1193,8 +1189,8 @@ list<_Tp, _Alloc>::erase(const_iterator __f, const_iterator __l)
            __node& __n = const_cast<__node&>(*__f.__ptr_);
            ++__f;
            --base::__sz();
-            __node_alloc_traits::destroy(__na, _STD::addressof(__n.__value_));
-            __node_alloc_traits::deallocate(__na, _STD::addressof(__n), 1);
+            __node_alloc_traits::destroy(__na, addressof(__n.__value_));
+            __node_alloc_traits::deallocate(__na, addressof(__n), 1);
        }
    }
    return iterator(const_cast<__node_pointer>(__l.__ptr_));
@@ -1214,7 +1210,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_));
+        __node_alloc_traits::construct(__na, addressof(__hold->__value_));
        ++__ds;
        iterator __r = iterator(__hold.release());
        iterator __e = __r;
@@ -1225,7 +1221,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
            for (--__n; __n != 0; --__n, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_));
+                __node_alloc_traits::construct(__na, addressof(__hold->__value_));
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -1236,7 +1232,7 @@ list<_Tp, _Alloc>::resize(size_type __n)
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -1265,7 +1261,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
        typedef __allocator_destructor<__node_allocator> _D;
        unique_ptr<__node, _D> __hold(__node_alloc_traits::allocate(__na, 1), _D(__na, 1));
        __hold->__prev_ = 0;
-        __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+        __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
        ++__ds;
        iterator __r = iterator(__hold.release());
        iterator __e = __r;
@@ -1276,7 +1272,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
            for (--__n; __n != 0; --__n, ++__e, ++__ds)
            {
                __hold.reset(__node_alloc_traits::allocate(__na, 1));
-                __node_alloc_traits::construct(__na, _STD::addressof(__hold->__value_), __x);
+                __node_alloc_traits::construct(__na, addressof(__hold->__value_), __x);
                __e.__ptr_->__next_ = __hold.get();
                __hold->__prev_ = __e.__ptr_;
                __hold.release();
@@ -1287,7 +1283,7 @@ list<_Tp, _Alloc>::resize(size_type __n, const value_type& __x)
        {
            while (true)
            {
-                __node_alloc_traits::destroy(__na, _STD::addressof(*__e));
+                __node_alloc_traits::destroy(__na, addressof(*__e));
                __node_pointer __prev = __e.__ptr_->__prev_;
                __node_alloc_traits::deallocate(__na, __e.__ptr_, 1);
                if (__prev == 0)
@@ -1321,7 +1317,7 @@ template <class _Tp, class _Alloc>
 void
 list<_Tp, _Alloc>::splice(const_iterator __p, list& __c, const_iterator __i)
 {
-    if (__p != __i && __p != _STD::next(__i))
+    if (__p != __i && __p != next(__i))
    {
        __node& __f = const_cast<__node&>(*__i.__ptr_);
        base::__unlink_nodes(__f, __f);
@@ -1359,7 +1355,7 @@ list<_Tp, _Alloc>::remove(const value_type& __x)
    {
        if (*__i == __x)
        {
-            iterator __j = _STD::next(__i);
+            iterator __j = next(__i);
            for (; __j != __e && *__j == __x; ++__j)
                ;
            __i = erase(__i, __j);
@@ -1378,7 +1374,7 @@ list<_Tp, _Alloc>::remove_if(_Pred __pred)
    {
        if (__pred(*__i))
        {
-            iterator __j = _STD::next(__i);
+            iterator __j = next(__i);
            for (; __j != __e && __pred(*__j); ++__j)
                ;
            __i = erase(__i, __j);
@@ -1403,7 +1399,7 @@ list<_Tp, _Alloc>::unique(_BinaryPred __binary_pred)
 {
    for (iterator __i = begin(), __e = end(); __i != __e;)
    {
-        iterator __j = _STD::next(__i);
+        iterator __j = next(__i);
        for (; __j != __e && __binary_pred(*__i, *__j); ++__j)
            ;
        if (++__i != __j)
@@ -1435,7 +1431,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
            if (__comp(*__f2, *__f1))
            {
                size_type __ds = 1;
-                iterator __m2 = _STD::next(__f2);
+                iterator __m2 = next(__f2);
                for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2, ++__ds)
                    ;
                base::__sz() += __ds;
@@ -1444,7 +1440,7 @@ list<_Tp, _Alloc>::merge(list& __c, _Comp __comp)
                __node& __l = *__m2.__ptr_->__prev_;
                __f2 = __m2;
                base::__unlink_nodes(__f, __l);
-                __m2 = _STD::next(__f1);
+                __m2 = next(__f1);
                __link_nodes(*__f1.__ptr_, __f, __l);
                __f1 = __m2;
            }
@@ -1493,12 +1489,12 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
        return __f1;
    }
    size_type __n2 = __n / 2;
-    iterator __e1 = _STD::next(__f1, __n2);
+    iterator __e1 = next(__f1, __n2);
    iterator  __r = __f1 = __sort(__f1, __e1, __n2, __comp);
    iterator __f2 = __e1 = __sort(__e1, __e2, __n - __n2, __comp);
    if (__comp(*__f2, *__f1))
    {
-        iterator __m2 = _STD::next(__f2);
+        iterator __m2 = next(__f2);
        for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
            ;
        __node& __f = *__f2.__ptr_;
@@ -1506,7 +1502,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
        __r = __f2;
        __e1 = __f2 = __m2;
        base::__unlink_nodes(__f, __l);
-        __m2 = _STD::next(__f1);
+        __m2 = next(__f1);
        __link_nodes(*__f1.__ptr_, __f, __l);
        __f1 = __m2;
    }
@@ -1516,7 +1512,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
    {
        if (__comp(*__f2, *__f1))
        {
-            iterator __m2 = _STD::next(__f2);
+            iterator __m2 = next(__f2);
            for (; __m2 != __e2 && __comp(*__m2, *__f1); ++__m2)
                ;
            __node& __f = *__f2.__ptr_;
@@ -1525,7 +1521,7 @@ list<_Tp, _Alloc>::__sort(iterator __f1, iterator __e2, size_type __n, _Comp& __
                __e1 = __m2;
            __f2 = __m2;
            base::__unlink_nodes(__f, __l);
-            __m2 = _STD::next(__f1);
+            __m2 = next(__f1);
            __link_nodes(*__f1.__ptr_, __f, __l);
            __f1 = __m2;
        }
--- a/include/locale
+++ b/include/locale
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -265,10 +265,7 @@ __nolocale_isdigit(int __c)
 }

 #else  // __APPLE__
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 int
 __nolocale_sprintf(char* __restrict __str,
                   const char* __restrict __format, ...)
@@ -279,10 +276,7 @@ __nolocale_sprintf(char* __restrict __str,
    va_end(__ap);
    return __result;
 }
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 int
 __nolocale_snprintf(char* __restrict __str, size_t __size,
                    const char* __restrict __format, ...)
@@ -293,10 +287,7 @@ __nolocale_snprintf(char* __restrict __str, size_t __size,
    va_end(__ap);
    return __result;
 }
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 int
 __nolocale_asprintf(char** __ret,
                    const char* __restrict __format, ...)
@@ -307,10 +298,7 @@ __nolocale_asprintf(char** __ret,
    va_end(__ap);
    return __result;
 }
-inline
-#ifndef _LIBCPP_HAS_NO_ALWAYS_INLINE_VARIADICS
-_LIBCPP_INLINE_VISIBILITY
-#endif
+inline _LIBCPP_INLINE_VISIBILITY
 int
 __nolocale_sscanf(const char* __restrict __str,
                  const char* __restrict __format, ...)
@@ -522,12 +510,6 @@ __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*&
                  unsigned& __dc, _CharT __thousands_sep, const string& __grouping,
                  unsigned* __g, unsigned*& __g_end, _CharT* __atoms)
 {
-    if (__a_end == __a && (__ct == __atoms[24] || __ct == __atoms[25]))
-    {
-        *__a_end++ = __ct == __atoms[24] ? '+' : '-';
-        __dc = 0;
-        return 0;
-    }
    if (__ct == __thousands_sep && __grouping.size() != 0)
    {
        if (__g_end-__g < __num_get_buf_sz)
@@ -538,28 +520,22 @@ __num_get<_CharT>::__stage2_int_loop(_CharT __ct, int __base, char* __a, char*&
        return 0;
    }
    ptrdiff_t __f = find(__atoms, __atoms + 26, __ct) - __atoms;
-    if (__f >= 24)
+    if (__f >= 26)
        return -1;
+    if (__a_end-__a < __num_get_buf_sz - 1)
+        *__a_end++ = __src[__f];
    switch (__base)
    {
    case 8:
    case 10:
        if (__f >= __base)
-            return -1;
-        break;
-    case 16:
-        if (__f < 22)
-            break;
-        if (__a_end != __a && __a_end - __a <= 2 && __a_end[-1] == '0')
-        {
-            __dc = 0;
-            *__a_end++ = __src[__f];
            return 0;
-        }
-        return -1;
+        break;
+    default:
+        if (__f >= 22)
+            return 0;
+        break;
    }
-    if (__a_end-__a < __num_get_buf_sz - 1)
-        *__a_end++ = __src[__f];
    ++__dc;
    return 0;
 }
@@ -745,27 +721,22 @@ __num_get_signed_integral(const char* __a, const char* __a_end,
 {
    if (__a != __a_end)
    {
-        int __save_errno = errno;
-        errno = 0;
        char *__p2;
        long long __ll = strtoll_l(__a, &__p2, __base, 0);
-        int __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
        if (__p2 != __a_end)
        {
            __err = ios_base::failbit;
            return 0;
        }
-        else if (__current_errno == ERANGE         ||
-                 __ll < numeric_limits<_Tp>::min() ||
-                 numeric_limits<_Tp>::max() < __ll)
+        else if (__ll > numeric_limits<_Tp>::max())
        {
            __err = ios_base::failbit;
-            if (__ll > 0)
-                return numeric_limits<_Tp>::max();
-            else
-                return numeric_limits<_Tp>::min();
+            return numeric_limits<_Tp>::max();
+        }
+        else if (__ll < numeric_limits<_Tp>::min())
+        {
+            __err = ios_base::failbit;
+            return numeric_limits<_Tp>::min();
        }
        return static_cast<_Tp>(__ll);
    }
@@ -780,25 +751,14 @@ __num_get_unsigned_integral(const char* __a, const char* __a_end,
 {
    if (__a != __a_end)
    {
-        if (*__a == '-')
-        {
-            __err = ios_base::failbit;
-            return 0;
-        }
-        int __save_errno = errno;
-        errno = 0;
        char *__p2;
        unsigned long long __ll = strtoull_l(__a, &__p2, __base, 0);
-        int __current_errno = errno;
-        if (__current_errno == 0)
-            errno = __save_errno;
        if (__p2 != __a_end)
        {
            __err = ios_base::failbit;
            return 0;
        }
-        else if (__current_errno == ERANGE ||
-                 numeric_limits<_Tp>::max() < __ll)
+        else if (__ll > numeric_limits<_Tp>::max())
        {
            __err = ios_base::failbit;
            return numeric_limits<_Tp>::max();
@@ -1796,7 +1756,7 @@ public:
 };

 template <class _CharT>
-class __time_get_c_storage  // purposefully not decorated
+class __time_get_c_storage
 {
 protected:
    typedef basic_string<_CharT> string_type;
@@ -2608,7 +2568,7 @@ time_put<_CharT, _OutputIterator>::do_put(iter_type __s, ios_base& __iob,
    char_type* __nb = __nar;
    char_type* __ne = __nb + 100;
    __do_put(__nb, __ne, __tm, __fmt, __mod);
-    return _STD::copy(__nb, __ne, __s);
+    return copy(__nb, __ne, __s);
 }

 extern template class time_put<char>;
@@ -2678,15 +2638,24 @@ protected:
    _LIBCPP_ALWAYS_INLINE
    ~moneypunct() {}

+    _LIBCPP_ALWAYS_INLINE
    virtual char_type   do_decimal_point() const {return numeric_limits<char_type>::max();}
+    _LIBCPP_ALWAYS_INLINE
    virtual char_type   do_thousands_sep() const {return numeric_limits<char_type>::max();}
+    _LIBCPP_ALWAYS_INLINE
    virtual string      do_grouping()      const {return string();}
+    _LIBCPP_ALWAYS_INLINE
    virtual string_type do_curr_symbol()   const {return string_type();}
+    _LIBCPP_ALWAYS_INLINE
    virtual string_type do_positive_sign() const {return string_type();}
+    _LIBCPP_ALWAYS_INLINE
    virtual string_type do_negative_sign() const {return string_type(1, '-');}
+    _LIBCPP_ALWAYS_INLINE
    virtual int         do_frac_digits()   const {return 0;}
+    _LIBCPP_ALWAYS_INLINE
    virtual pattern     do_pos_format()    const
        {pattern __p = {symbol, sign, none, value}; return __p;}
+    _LIBCPP_ALWAYS_INLINE
    virtual pattern     do_neg_format()    const
        {pattern __p = {symbol, sign, none, value}; return __p;}
 };
@@ -2723,14 +2692,23 @@ protected:
    _LIBCPP_ALWAYS_INLINE
    ~moneypunct_byname() {}

+    _LIBCPP_ALWAYS_INLINE
    virtual char_type   do_decimal_point() const {return __decimal_point_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual char_type   do_thousands_sep() const {return __thousands_sep_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual string      do_grouping()      const {return __grouping_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual string_type do_curr_symbol()   const {return __curr_symbol_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual string_type do_positive_sign() const {return __positive_sign_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual string_type do_negative_sign() const {return __negative_sign_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual int         do_frac_digits()   const {return __frac_digits_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual pattern     do_pos_format()    const {return __pos_format_;}
+    _LIBCPP_ALWAYS_INLINE
    virtual pattern     do_neg_format()    const {return __neg_format_;}

 private:
@@ -3276,7 +3254,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
            break;
        case money_base::symbol:
            if (!__sym.empty() && (__flags & ios_base::showbase))
-                __me = _STD::copy(__sym.begin(), __sym.end(), __me);
+                __me = copy(__sym.begin(), __sym.end(), __me);
            break;
        case money_base::value:
            {
@@ -3335,7 +3313,7 @@ __money_put<_CharT>::__format(char_type* __mb, char_type*& __mi, char_type*& __m
    }
    // print rest of sign, if any
    if (__sn.size() > 1)
-        __me = _STD::copy(__sn.begin()+1, __sn.end(), __me);
+        __me = copy(__sn.begin()+1, __sn.end(), __me);
    // set alignment
    if ((__flags & ios_base::adjustfield) == ios_base::left)
        __mi = __me;
@@ -3502,7 +3480,7 @@ extern template class money_put<wchar_t>;
 class _LIBCPP_VISIBLE messages_base
 {
 public:
-    typedef ptrdiff_t catalog;
+    typedef nl_catd catalog;

    _LIBCPP_ALWAYS_INLINE messages_base() {}
 };
@@ -3559,10 +3537,7 @@ template <class _CharT>
 typename messages<_CharT>::catalog
 messages<_CharT>::do_open(const basic_string<char>& __nm, const locale&) const
 {
-    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;
+    return catopen(__nm.c_str(), NL_CAT_LOCALE);
 }

 template <class _CharT>
@@ -3574,10 +3549,7 @@ messages<_CharT>::do_get(catalog __c, int __set, int __msgid,
    __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 = reinterpret_cast<nl_catd>(__c);
-    char* __n = catgets(__cat, __set, __msgid, __ndflt.c_str());
+    char* __n = catgets(__c, __set, __msgid, __ndflt.c_str());
    string_type __w;
    __widen_from_utf8<sizeof(char_type)*__CHAR_BIT__>()(back_inserter(__w),
                                                        __n, __n + strlen(__n));
@@ -3588,10 +3560,7 @@ template <class _CharT>
 void
 messages<_CharT>::do_close(catalog __c) const
 {
-    if (__c != -1)
-        __c <<= 1;
-    nl_catd __cat = reinterpret_cast<nl_catd>(__c);
-    catclose(__cat);
+    catclose(__c);
 }

 extern template class messages<char>;
@@ -4004,7 +3973,7 @@ wbuffer_convert<_Codecvt, _Elem, _Tr>::underflow()
            memmove(__extbuf_, __extbufnext_, __extbufend_ - __extbufnext_);
            __extbufnext_ = __extbuf_ + (__extbufend_ - __extbufnext_);
            __extbufend_ = __extbuf_ + (__extbuf_ == __extbuf_min_ ? sizeof(__extbuf_min_) : __ebs_);
-            streamsize __nmemb = _STD::min(static_cast<streamsize>(this->egptr() - this->eback() - __unget_sz),
+            streamsize __nmemb = 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
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -350,7 +350,7 @@ template <class _Key, class _Tp, class _Compare, bool = is_empty<_Compare>::valu
 class __map_value_compare
    : private _Compare
 {
-    typedef pair<typename std::remove_const<_Key>::type, _Tp> _P;
+    typedef pair<_Key, _Tp> _P;
    typedef pair<const _Key, _Tp> _CP;
 public:
    _LIBCPP_INLINE_VISIBILITY
@@ -393,7 +393,7 @@ class __map_value_compare<_Key, _Tp, _Compare, false>
 {
    _Compare comp;

-    typedef pair<typename std::remove_const<_Key>::type, _Tp> _P;
+    typedef pair<_Key, _Tp> _P;
    typedef pair<const _Key, _Tp> _CP;

 public:
@@ -475,9 +475,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -493,11 +493,11 @@ class _LIBCPP_VISIBLE __map_iterator
    _TreeIterator __i_;

    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
-    typedef const typename _TreeIterator::value_type::first_type __key_type;
-    typedef typename _TreeIterator::value_type::second_type      __mapped_type;
+    typedef const typename _TreeIterator::value_type::first_type key_type;
+    typedef typename _TreeIterator::value_type::second_type      mapped_type;
 public:
    typedef bidirectional_iterator_tag                           iterator_category;
-    typedef pair<__key_type, __mapped_type>                      value_type;
+    typedef pair<key_type, mapped_type>                          value_type;
    typedef typename _TreeIterator::difference_type              difference_type;
    typedef value_type&                                          reference;
    typedef typename __pointer_traits::template
@@ -558,11 +558,11 @@ class _LIBCPP_VISIBLE __map_const_iterator
    _TreeIterator __i_;

    typedef typename _TreeIterator::__pointer_traits             __pointer_traits;
-    typedef const typename _TreeIterator::value_type::first_type __key_type;
-    typedef typename _TreeIterator::value_type::second_type      __mapped_type;
+    typedef const typename _TreeIterator::value_type::first_type key_type;
+    typedef typename _TreeIterator::value_type::second_type      mapped_type;
 public:
    typedef bidirectional_iterator_tag                           iterator_category;
-    typedef pair<__key_type, __mapped_type>                      value_type;
+    typedef pair<key_type, mapped_type>                          value_type;
    typedef typename _TreeIterator::difference_type              difference_type;
    typedef const value_type&                                    reference;
    typedef typename __pointer_traits::template
@@ -1042,7 +1042,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__find_equal_key(const_iterator __hint,
    else if (__tree_.value_comp().key_comp()(__hint->first, __k))  // check after
    {
        // *__hint < __k
-        const_iterator __next = _STD::next(__hint);
+        const_iterator __next = next(__hint);
        if (__next == end() || __tree_.value_comp().key_comp()(__k, __next->first))
        {
            // *__hint < __k < *next(__hint)
@@ -1131,9 +1131,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node()
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first));
+    __node_traits::construct(__na, addressof(__h->__value_.first));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
@@ -1146,7 +1146,7 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -1162,9 +1162,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&& ...__
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
@@ -1179,9 +1179,9 @@ map<_Key, _Tp, _Compare, _Allocator>::__construct_node(const key_type& __k)
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return _STD::move(__h);
 }
@@ -1685,9 +1685,9 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node()
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first));
+    __node_traits::construct(__na, addressof(__h->__value_.first));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
@@ -1701,7 +1701,7 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0)
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, addressof(__h->__value_), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -1718,9 +1718,9 @@ multimap<_Key, _Tp, _Compare, _Allocator>::__construct_node(_A0&& __a0, _Args&&
 {
    __node_allocator& __na = __tree_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
+    __node_traits::construct(__na, addressof(__h->__value_.first), _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
+    __node_traits::construct(__na, addressof(__h->__value_.second), _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
 }
--- a/include/memory
+++ b/include/memory
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -52,11 +52,8 @@ struct allocator_traits
          | pointer_traits<pointer>::rebind<const void>
                                         const_void_pointer;
    typedef Alloc::difference_type
-          | pointer_traits<pointer>::difference_type
-                                         difference_type;
-    typedef Alloc::size_type
-          | make_unsigned<difference_type>::type
-                                         size_type;
+          | ptrdiff_t                    difference_type;
+    typedef Alloc::size_type | size_t    size_type;
    typedef Alloc::propagate_on_container_copy_assignment
          | false_type                   propagate_on_container_copy_assignment;
    typedef Alloc::propagate_on_container_move_assignment
@@ -155,8 +152,7 @@ template <class ForwardIterator, class T>
 void uninitialized_fill(ForwardIterator first, ForwardIterator last, const T& x);

 template <class ForwardIterator, class Size, class T>
-ForwardIterator
-uninitialized_fill_n(ForwardIterator first, Size n, const T& x);
+void uninitialized_fill_n(ForwardIterator first, Size n, const T& x);

 template <class Y> struct auto_ptr_ref {};

@@ -860,7 +856,7 @@ struct __pointer_type<_Tp, _Dp, false>
    typedef _Tp* type;
 };

-}  // __pointer_type_imp
+}

 template <class _Tp, class _Dp>
 struct __pointer_type
@@ -976,14 +972,14 @@ public:
    static const bool value = sizeof(__test<_Tp>(0)) == 1;
 };

-template <class _Alloc, class _DiffType, bool = __has_size_type<_Alloc>::value>
+template <class _Alloc, bool = __has_size_type<_Alloc>::value>
 struct __size_type
 {
-    typedef typename make_unsigned<_DiffType>::type type;
+    typedef size_t type;
 };

-template <class _Alloc, class _DiffType>
-struct __size_type<_Alloc, _DiffType, true>
+template <class _Alloc>
+struct __size_type<_Alloc, true>
 {
    typedef typename _Alloc::size_type type;
 };
@@ -1296,18 +1292,6 @@ struct __has_select_on_container_copy_construction

 #endif  // _LIBCPP_HAS_NO_ADVANCED_SFINAE

-template <class _Alloc, class _Ptr, bool = __has_difference_type<_Alloc>::value>
-struct __alloc_traits_difference_type
-{
-    typedef typename pointer_traits<_Ptr>::difference_type type;
-};
-
-template <class _Alloc, class _Ptr>
-struct __alloc_traits_difference_type<_Alloc, _Ptr, true>
-{
-    typedef typename _Alloc::difference_type type;
-};
-
 template <class _Alloc>
 struct _LIBCPP_VISIBLE allocator_traits
 {
@@ -1319,8 +1303,8 @@ struct _LIBCPP_VISIBLE allocator_traits
    typedef typename __void_pointer<pointer, allocator_type>::type void_pointer;
    typedef typename __const_void_pointer<pointer, allocator_type>::type const_void_pointer;

-    typedef typename __alloc_traits_difference_type<allocator_type, pointer>::type difference_type;
-    typedef typename __size_type<allocator_type, difference_type>::type size_type;
+    typedef typename __pointer_traits_difference_type<allocator_type>::type difference_type;
+    typedef typename __size_type<allocator_type>::type size_type;

    typedef typename __propagate_on_container_copy_assignment<allocator_type>::type
                     propagate_on_container_copy_assignment;
@@ -1487,7 +1471,7 @@ struct _LIBCPP_VISIBLE uses_allocator
 {
 };

-#ifndef _LIBCPP_HAS_NO_VARIADICS
+#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)

 // uses-allocator construction

@@ -1505,7 +1489,7 @@ struct __uses_alloc_ctor
    : integral_constant<int, __uses_alloc_ctor_imp<_Tp, _Alloc, _Args...>::value>
    {};

-#endif  // _LIBCPP_HAS_NO_VARIADICS
+#endif  // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_ADVANCED_SFINAE)

 // allocator

@@ -1525,8 +1509,8 @@ public:

    _LIBCPP_INLINE_VISIBILITY allocator() throw() {}
    template <class _Up> _LIBCPP_INLINE_VISIBILITY allocator(const allocator<_Up>&) throw() {}
-    _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const             {return _STD::addressof(__x);}
-    _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const {return _STD::addressof(__x);}
+    _LIBCPP_INLINE_VISIBILITY pointer address(reference __x) const             {return addressof(__x);}
+    _LIBCPP_INLINE_VISIBILITY const_pointer address(const_reference __x) const {return addressof(__x);}
    _LIBCPP_INLINE_VISIBILITY pointer allocate(size_type __n, allocator<void>::const_pointer = 0)
        {return static_cast<pointer>(::operator new(__n * sizeof(_Tp)));}
    _LIBCPP_INLINE_VISIBILITY void deallocate(pointer __p, size_type) {::operator delete((void*)__p);}
@@ -1546,7 +1530,6 @@ public:
        {
            ::new((void*)__p) _Tp();
        }
-# if defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
    template <class _A0>
        _LIBCPP_INLINE_VISIBILITY
        typename enable_if
@@ -1580,7 +1563,6 @@ public:
        {
            ::new((void*)__p) _Tp(_STD::move(__a0));
        }
-# endif  // defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES)
    template <class _A0, class _A1>
        _LIBCPP_INLINE_VISIBILITY
        void
@@ -2448,15 +2430,15 @@ public:

    template <class _Tp>
    _LIBCPP_INLINE_VISIBILITY void __incr(_Tp*)
-        {__incr(integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+        {__incr(integral_constant<bool, has_trivial_destructor<_Tp>::value>());}

    template <class _Tp>
    _LIBCPP_INLINE_VISIBILITY void __set(size_t __s, _Tp*)
-        {__set(__s, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+        {__set(__s, integral_constant<bool, has_trivial_destructor<_Tp>::value>());}

    template <class _Tp>
    _LIBCPP_INLINE_VISIBILITY void operator()(_Tp* __p)
-        {__process(__p, integral_constant<bool, is_trivially_destructible<_Tp>::value>());}
+        {__process(__p, integral_constant<bool, has_trivial_destructor<_Tp>::value>());}
 };

 template <class _Alloc>
@@ -2515,7 +2497,7 @@ uninitialized_fill(_ForwardIterator __f, _ForwardIterator __l, const _Tp& __x)
 }

 template <class _ForwardIterator, class _Size, class _Tp>
-_ForwardIterator
+void
 uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x)
 {
    __destruct_n __d(0);
@@ -2524,7 +2506,6 @@ uninitialized_fill_n(_ForwardIterator __f, _Size __n, const _Tp& __x)
    for (; __n > 0; ++__f, --__n, __d.__incr((value_type*)0))
        ::new(&*__f) value_type(__x);
    __h.release();
-    return __f;
 }

 class _LIBCPP_EXCEPTION_ABI bad_weak_ptr
@@ -2554,7 +2535,7 @@ public:
        : __shared_owners_(__refs) {}

    void __add_shared();
-    bool __release_shared();
+    void __release_shared();
    _LIBCPP_INLINE_VISIBILITY
    long use_count() const {return __shared_owners_ + 1;}
 };
--- a/include/mutex
+++ b/include/mutex
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -221,7 +221,7 @@ public:
    template <class _Rep, class _Period>
        _LIBCPP_INLINE_VISIBILITY
        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-            {return try_lock_until(chrono::steady_clock::now() + __d);}
+            {return try_lock_until(chrono::monotonic_clock::now() + __d);}
    template <class _Clock, class _Duration>
        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
    void unlock();
@@ -264,7 +264,7 @@ public:
    template <class _Rep, class _Period>
        _LIBCPP_INLINE_VISIBILITY
        bool try_lock_for(const chrono::duration<_Rep, _Period>& __d)
-            {return try_lock_until(chrono::steady_clock::now() + __d);}
+            {return try_lock_until(chrono::monotonic_clock::now() + __d);}
    template <class _Clock, class _Duration>
        bool try_lock_until(const chrono::time_point<_Clock, _Duration>& __t);
    void unlock();
@@ -364,9 +364,9 @@ lock(_L0& __l0, _L1& __l1)

 #ifndef _LIBCPP_HAS_NO_VARIADICS

-template <class _L0, class _L1, class _L2, class ..._L3>
+template <class _L0, class _L1, class ..._L2>
 void
-__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
+__lock_first(int __i, _L0& __l0, _L1& __l1, _L2& ...__l2)
 {
    while (true)
    {
@@ -375,7 +375,7 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
        case 0:
            {
                unique_lock<_L0> __u0(__l0);
-                __i = try_lock(__l1, __l2, __l3...);
+                __i = try_lock(__l1, __l2...);
                if (__i == -1)
                {
                    __u0.release();
@@ -388,32 +388,32 @@ __lock_first(int __i, _L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
        case 1:
            {
                unique_lock<_L1> __u1(__l1);
-                __i = try_lock(__l2, __l3..., __l0);
+                __i = try_lock(__l2..., __l0);
                if (__i == -1)
                {
                    __u1.release();
                    return;
                }
            }
-            if (__i == sizeof...(_L3) + 1)
+            if (__i == sizeof...(_L2))
                __i = 0;
            else
                __i += 2;
            sched_yield();
            break;
        default:
-            __lock_first(__i - 2, __l2, __l3..., __l0, __l1);
+            __lock_first(__i - 2, __l2..., __l0, __l1);
            return;
        }
    }
 }

-template <class _L0, class _L1, class _L2, class ..._L3>
+template <class _L0, class _L1, class ..._L2>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-lock(_L0& __l0, _L1& __l1, _L2& __l2, _L3& ...__l3)
+lock(_L0& __l0, _L1& __l1, _L2& ...__l2)
 {
-    __lock_first(0, __l0, __l1, __l2, __l3...);
+    __lock_first(0, __l0, __l1, __l2...);
 }

 #endif  // _LIBCPP_HAS_NO_VARIADICS
--- a/include/new
+++ b/include/new
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -32,7 +32,6 @@ struct nothrow_t {};
 extern const nothrow_t nothrow;
 typedef void (*new_handler)();
 new_handler set_new_handler(new_handler new_p) throw();
-new_handler get_new_handler() throw();

 }  // std

@@ -86,7 +85,6 @@ 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) throw();
-_LIBCPP_VISIBLE new_handler get_new_handler() throw();

 }  // std

--- a/include/numeric
+++ b/include/numeric
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/ostream
+++ b/include/ostream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -1276,7 +1276,7 @@ operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Y> const& __p)

 template <class _CharT, class _Traits, size_t _Size>
 basic_ostream<_CharT, _Traits>&
-operator<<(basic_ostream<_CharT, _Traits>& __os, const bitset<_Size>& __x)
+operator<<(basic_ostream<_CharT, _Traits>& __os, bitset<_Size>& __x)
 {
    return __os << __x.template to_string<_CharT, _Traits>
                        (use_facet<ctype<_CharT> >(__os.getloc()).widen('0'),
--- a/include/queue
+++ b/include/queue
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/random
+++ b/include/random
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -1498,7 +1498,7 @@ class piecewise_constant_distribution
                       UnaryOperation fw);

        vector<result_type> intervals() const;
-        vector<result_type> densities() const;
+        vector<double> densities() const;

        friend bool operator==(const param_type& x, const param_type& y);
        friend bool operator!=(const param_type& x, const param_type& y);
@@ -1525,7 +1525,7 @@ class piecewise_constant_distribution

    // property functions
    vector<result_type> intervals() const;
-    vector<result_type> densities() const;
+    vector<double> densities() const;

    param_type param() const;
    void param(const param_type& parm);
@@ -1573,7 +1573,7 @@ class piecewise_linear_distribution
                       UnaryOperation fw);

        vector<result_type> intervals() const;
-        vector<result_type> densities() const;
+        vector<double> densities() const;

        friend bool operator==(const param_type& x, const param_type& y);
        friend bool operator!=(const param_type& x, const param_type& y);
@@ -1603,7 +1603,7 @@ class piecewise_linear_distribution

    // property functions
    vector<result_type> intervals() const;
-    vector<result_type> densities() const;
+    vector<double> densities() const;

    param_type param() const;
    void param(const param_type& parm);
@@ -5922,9 +5922,10 @@ public:

    class _LIBCPP_VISIBLE param_type
    {
+        typedef typename common_type<double, result_type>::type __area_type;
        vector<result_type> __b_;
-        vector<result_type> __densities_;
-        vector<result_type> __areas_;
+        vector<double> __densities_;
+        vector<__area_type> __areas_;
    public:
        typedef piecewise_constant_distribution distribution_type;

@@ -5942,7 +5943,7 @@ public:
        _LIBCPP_INLINE_VISIBILITY
        vector<result_type> intervals() const {return __b_;}
        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> densities() const {return __densities_;}
+        vector<double> densities() const {return __densities_;}

        friend _LIBCPP_INLINE_VISIBILITY
            bool operator==(const param_type& __x, const param_type& __y)
@@ -6013,7 +6014,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    vector<result_type> intervals() const {return __p_.intervals();}
    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> densities() const {return __p_.densities();}
+    vector<double> densities() const {return __p_.densities();}

    _LIBCPP_INLINE_VISIBILITY
    param_type param() const {return __p_;}
@@ -6069,13 +6070,13 @@ void
 piecewise_constant_distribution<_RealType>::param_type::__init()
 {
    // __densities_ contains non-normalized areas
-    result_type __total_area = _STD::accumulate(__densities_.begin(),
+    __area_type __total_area = _STD::accumulate(__densities_.begin(),
                                                __densities_.end(),
-                                                result_type());
+                                                __area_type());
    for (size_t __i = 0; __i < __densities_.size(); ++__i)
        __densities_[__i] /= __total_area;
    // __densities_ contains normalized areas
-    __areas_.assign(__densities_.size(), result_type());
+    __areas_.assign(__densities_.size(), __area_type());
    _STD::partial_sum(__densities_.begin(), __densities_.end() - 1,
                                                          __areas_.begin() + 1);
    // __areas_ contains partial sums of normalized areas: [0, __densities_ - 1]
@@ -6166,8 +6167,9 @@ piecewise_constant_distribution<_RealType>::operator()(_URNG& __g, const param_t
    typedef uniform_real_distribution<result_type> _Gen;
    result_type __u = _Gen()(__g);
    ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
-                                      __u) - __p.__areas_.begin() - 1;
-    return (__u - __p.__areas_[__k]) / __p.__densities_[__k] + __p.__b_[__k];
+                               static_cast<double>(__u)) - __p.__areas_.begin() - 1;
+    return static_cast<result_type>((__u - __p.__areas_[__k]) / __p.__densities_[__k]
+                                    + __p.__b_[__k]);
 }

 template <class _CharT, class _Traits, class _RT>
@@ -6203,6 +6205,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
    typedef piecewise_constant_distribution<_RT> _Eng;
    typedef typename _Eng::result_type result_type;
    typedef typename _Eng::param_type param_type;
+    typedef typename param_type::__area_type __area_type;
    __save_flags<_CharT, _Traits> _(__is);
    __is.flags(ios_base::dec | ios_base::skipws);
    size_t __n;
@@ -6211,11 +6214,11 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
    for (size_t __i = 0; __i < __n; ++__i)
        __is >> __b[__i];
    __is >> __n;
-    vector<result_type> __densities(__n);
+    vector<double> __densities(__n);
    for (size_t __i = 0; __i < __n; ++__i)
        __is >> __densities[__i];
    __is >> __n;
-    vector<result_type> __areas(__n);
+    vector<__area_type> __areas(__n);
    for (size_t __i = 0; __i < __n; ++__i)
        __is >> __areas[__i];
    if (!__is.fail())
@@ -6238,9 +6241,10 @@ public:

    class _LIBCPP_VISIBLE param_type
    {
+        typedef typename common_type<double, result_type>::type __area_type;
        vector<result_type> __b_;
-        vector<result_type> __densities_;
-        vector<result_type> __areas_;
+        vector<double> __densities_;
+        vector<__area_type> __areas_;
    public:
        typedef piecewise_linear_distribution distribution_type;

@@ -6258,7 +6262,7 @@ public:
        _LIBCPP_INLINE_VISIBILITY
        vector<result_type> intervals() const {return __b_;}
        _LIBCPP_INLINE_VISIBILITY
-        vector<result_type> densities() const {return __densities_;}
+        vector<double> densities() const {return __densities_;}

        friend _LIBCPP_INLINE_VISIBILITY
            bool operator==(const param_type& __x, const param_type& __y)
@@ -6329,7 +6333,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    vector<result_type> intervals() const {return __p_.intervals();}
    _LIBCPP_INLINE_VISIBILITY
-    vector<result_type> densities() const {return __p_.densities();}
+    vector<double> densities() const {return __p_.densities();}

    _LIBCPP_INLINE_VISIBILITY
    param_type param() const {return __p_;}
@@ -6385,8 +6389,8 @@ template<class _RealType>
 void
 piecewise_linear_distribution<_RealType>::param_type::__init()
 {
-    __areas_.assign(__densities_.size() - 1, result_type());
-    result_type _S = 0;
+    __areas_.assign(__densities_.size() - 1, __area_type());
+    __area_type _S = 0;
    for (size_t __i = 0; __i < __areas_.size(); ++__i)
    {
        __areas_[__i] = (__densities_[__i+1] + __densities_[__i]) *
@@ -6487,19 +6491,19 @@ piecewise_linear_distribution<_RealType>::operator()(_URNG& __g, const param_typ
    typedef uniform_real_distribution<result_type> _Gen;
    result_type __u = _Gen()(__g);
    ptrdiff_t __k = _STD::upper_bound(__p.__areas_.begin(), __p.__areas_.end(),
-                                      __u) - __p.__areas_.begin() - 1;
+                               static_cast<double>(__u)) - __p.__areas_.begin() - 1;
    __u -= __p.__areas_[__k];
-    const result_type __dk = __p.__densities_[__k];
-    const result_type __dk1 = __p.__densities_[__k+1];
-    const result_type __deltad = __dk1 - __dk;
+    const double __dk = __p.__densities_[__k];
+    const double __dk1 = __p.__densities_[__k+1];
+    const double __deltad = __dk1 - __dk;
    const result_type __bk = __p.__b_[__k];
    if (__deltad == 0)
-        return __u / __dk + __bk;
+        return static_cast<result_type>(__u / __dk + __bk);
    const result_type __bk1 = __p.__b_[__k+1];
    const result_type __deltab = __bk1 - __bk;
-    return (__bk * __dk1 - __bk1 * __dk +
+    return static_cast<result_type>((__bk * __dk1 - __bk1 * __dk +
        _STD::sqrt(__deltab * (__deltab * __dk * __dk + 2 * __deltad * __u))) /
-        __deltad;
+        __deltad);
 }

 template <class _CharT, class _Traits, class _RT>
@@ -6535,6 +6539,7 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
    typedef piecewise_linear_distribution<_RT> _Eng;
    typedef typename _Eng::result_type result_type;
    typedef typename _Eng::param_type param_type;
+    typedef typename param_type::__area_type __area_type;
    __save_flags<_CharT, _Traits> _(__is);
    __is.flags(ios_base::dec | ios_base::skipws);
    size_t __n;
@@ -6543,11 +6548,11 @@ operator>>(basic_istream<_CharT, _Traits>& __is,
    for (size_t __i = 0; __i < __n; ++__i)
        __is >> __b[__i];
    __is >> __n;
-    vector<result_type> __densities(__n);
+    vector<double> __densities(__n);
    for (size_t __i = 0; __i < __n; ++__i)
        __is >> __densities[__i];
    __is >> __n;
-    vector<result_type> __areas(__n);
+    vector<__area_type> __areas(__n);
    for (size_t __i = 0; __i < __n; ++__i)
        __is >> __areas[__i];
    if (!__is.fail())
--- a/include/ratio
+++ b/include/ratio
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -23,14 +23,13 @@ class ratio
 public:
    static const intmax_t num;
    static const intmax_t den;
-    typedef ratio<num, den> type;
 };

 // ratio arithmetic
-template <class R1, class R2> using ratio_add = ...;
-template <class R1, class R2> using ratio_subtract = ...;
-template <class R1, class R2> using ratio_multiply = ...;
-template <class R1, class R2> using ratio_divide = ...;
+template <class R1, class R2> struct ratio_add;
+template <class R1, class R2> struct ratio_subtract;
+template <class R1, class R2> struct ratio_multiply;
+template <class R1, class R2> struct ratio_divide;

 // ratio comparison
 template <class R1, class R2> struct ratio_equal;
@@ -261,7 +260,7 @@ typedef ratio<   1000000000000000LL, 1LL> peta;
 typedef ratio<1000000000000000000LL, 1LL> exa;

 template <class _R1, class _R2>
-struct __ratio_multiply
+struct _LIBCPP_VISIBLE ratio_multiply
 {
 private:
    static const intmax_t __gcd_n1_d2 = __static_gcd<_R1::num, _R2::den>::value;
@@ -275,11 +274,7 @@ public:
 };

 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_multiply
-    : public __ratio_multiply<_R1, _R2>::type {};
-
-template <class _R1, class _R2>
-struct __ratio_divide
+struct _LIBCPP_VISIBLE ratio_divide
 {
 private:
    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -293,11 +288,7 @@ public:
 };

 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_divide
-    : public __ratio_divide<_R1, _R2>::type {};
-
-template <class _R1, class _R2>
-struct __ratio_add
+struct _LIBCPP_VISIBLE ratio_add
 {
 private:
    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -319,11 +310,7 @@ public:
 };

 template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_add
-    : public __ratio_add<_R1, _R2>::type {};
-
-template <class _R1, class _R2>
-struct __ratio_subtract
+struct _LIBCPP_VISIBLE ratio_subtract
 {
 private:
    static const intmax_t __gcd_n1_n2 = __static_gcd<_R1::num, _R2::num>::value;
@@ -344,10 +331,6 @@ public:
        >::type type;
 };

-template <class _R1, class _R2>
-struct _LIBCPP_VISIBLE ratio_subtract
-    : public __ratio_subtract<_R1, _R2>::type {};
-
 // ratio_equal

 template <class _R1, class _R2>
--- a/include/regex
+++ b/include/regex
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -208,8 +208,6 @@ public:

    bool matched;

-    constexpr sub_match();
-
    difference_type length() const;
    operator string_type() const;
    string_type str() const;
@@ -454,8 +452,6 @@ public:
    match_results& operator=(match_results&& m);
    ~match_results();

-    bool ready() const;
-
    // size:
    size_type size() const;
    size_type max_size() const;
@@ -1264,7 +1260,6 @@ struct __state
    vector<pair<size_t, const _CharT*> > __loop_data_;
    const __node<_CharT>* __node_;
    regex_constants::match_flag_type __flags_;
-    bool __at_first_;

    _LIBCPP_INLINE_VISIBILITY
    __state()
@@ -1891,40 +1886,6 @@ __word_boundary<_CharT, _Traits>::__exec(__state& __s) const
    }
 }

-// __l_anchor
-
-template <class _CharT>
-class __l_anchor
-    : public __owns_one_state<_CharT>
-{
-    typedef __owns_one_state<_CharT> base;
-
-public:
-    typedef _STD::__state<_CharT> __state;
-
-    _LIBCPP_INLINE_VISIBILITY
-    __l_anchor(__node<_CharT>* __s)
-        : base(__s) {}
-
-    virtual void __exec(__state&) const;
-};
-
-template <class _CharT>
-void
-__l_anchor<_CharT>::__exec(__state& __s) const
-{
-    if (__s.__at_first_ && __s.__current_ == __s.__first_)
-    {
-        __s.__do_ = __state::__accept_but_not_consume;
-        __s.__node_ = this->first();
-    }
-    else
-    {
-        __s.__do_ = __state::__reject;
-        __s.__node_ = nullptr;
-    }
-}
-
 // __r_anchor

 template <class _CharT>
@@ -2263,7 +2224,7 @@ __bracket_expression<_CharT, _Traits>::__exec(__state& __s) const
        ++__consumed;
        if (__might_have_digraph_)
        {
-            const _CharT* __next = _STD::next(__s.__current_);
+            const _CharT* __next = next(__s.__current_);
            if (__next != __s.__last_)
            {
                pair<_CharT, _CharT> __ch2(*__s.__current_, *__next);
@@ -2429,6 +2390,7 @@ private:
    int __open_count_;
    shared_ptr<__empty_state<_CharT> > __start_;
    __owns_one_state<_CharT>* __end_;
+    bool __left_anchor_;

    typedef _STD::__state<_CharT> __state;
    typedef _STD::__node<_CharT> __node;
@@ -2450,17 +2412,17 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    basic_regex()
        : __flags_(), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
        {}
    _LIBCPP_INLINE_VISIBILITY
    explicit basic_regex(const value_type* __p, flag_type __f = regex_constants::ECMAScript)
        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
        {__parse(__p, __p + __traits_.length(__p));}
    _LIBCPP_INLINE_VISIBILITY
    basic_regex(const value_type* __p, size_t __len, flag_type __f)
        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
        {__parse(__p, __p + __len);}
 //     basic_regex(const basic_regex&) = default;
 //     basic_regex(basic_regex&&) = default;
@@ -2469,20 +2431,20 @@ public:
        explicit basic_regex(const basic_string<value_type, _ST, _SA>& __p,
                             flag_type __f = regex_constants::ECMAScript)
        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
        {__parse(__p.begin(), __p.end());}
    template <class _ForwardIterator>
        _LIBCPP_INLINE_VISIBILITY
        basic_regex(_ForwardIterator __first, _ForwardIterator __last,
                    flag_type __f = regex_constants::ECMAScript)
        : __flags_(__f), __marked_count_(0), __loop_count_(0), __open_count_(0),
-          __end_(0)
+          __end_(0), __left_anchor_(false)
        {__parse(__first, __last);}
    _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)
+          __end_(0), __left_anchor_(false)
        {__parse(__il.begin(), __il.end());}

 //    ~basic_regex() = default;
@@ -2540,6 +2502,7 @@ private:
        __loop_count_ = 0;
        __open_count_ = 0;
        __end_ = nullptr;
+        __left_anchor_ = false;
    }
 public:

@@ -2727,7 +2690,7 @@ private:
                          basic_string<_CharT>* __str = nullptr);

    _LIBCPP_INLINE_VISIBILITY
-    void __push_l_anchor();
+    void __push_l_anchor() {__left_anchor_ = true;}
    void __push_r_anchor();
    void __push_match_any();
    void __push_match_any_but_newline();
@@ -2765,22 +2728,22 @@ private:
        bool
        __match_at_start(const _CharT* __first, const _CharT* __last,
                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
    template <class _Allocator>
        bool
        __match_at_start_ecma(const _CharT* __first, const _CharT* __last,
                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
    template <class _Allocator>
        bool
        __match_at_start_posix_nosubs(const _CharT* __first, const _CharT* __last,
                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;
    template <class _Allocator>
        bool
        __match_at_start_posix_subs(const _CharT* __first, const _CharT* __last,
                 match_results<const _CharT*, _Allocator>& __m,
-                 regex_constants::match_flag_type __flags, bool) const;
+                 regex_constants::match_flag_type __flags) const;

    template <class _B, class _A, class _C, class _T>
    friend
@@ -2842,6 +2805,7 @@ basic_regex<_CharT, _Traits>::swap(basic_regex& __r)
    swap(__open_count_, __r.__open_count_);
    swap(__start_, __r.__start_);
    swap(__end_, __r.__end_);
+    swap(__left_anchor_, __r.__left_anchor_);
 }

 template <class _CharT, class _Traits>
@@ -2882,9 +2846,7 @@ __lookahead<_CharT, _Traits>::__exec(__state& __s) const
    match_results<const _CharT*> __m;
    __m.__init(1 + __exp_.mark_count(), __s.__current_, __s.__last_);
    bool __matched = __exp_.__match_at_start_ecma(__s.__current_, __s.__last_,
-                                                  __m,
-                                                  __s.__flags_ | regex_constants::match_continuous,
-                                                  true);
+                                                  __m, __s.__flags_);
    if (__matched != __invert_)
    {
        __s.__do_ = __state::__accept_but_not_consume;
@@ -2953,7 +2915,7 @@ basic_regex<_CharT, _Traits>::__parse_basic_reg_exp(_ForwardIterator __first,
            __first = __parse_RE_expression(__first, __last);
            if (__first != __last)
            {
-                _ForwardIterator __temp = _STD::next(__first);
+                _ForwardIterator __temp = next(__first);
                if (__temp == __last && *__first == '$')
                {
                    __push_r_anchor();
@@ -3182,7 +3144,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_paren(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '(')
@@ -3200,7 +3162,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_paren(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == ')')
@@ -3218,7 +3180,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_open_brace(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '{')
@@ -3236,7 +3198,7 @@ basic_regex<_CharT, _Traits>::__parse_Back_close_brace(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && *__temp == '}')
@@ -3254,7 +3216,7 @@ basic_regex<_CharT, _Traits>::__parse_BACKREF(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\' && '1' <= *__temp && *__temp <= '9')
@@ -3275,7 +3237,7 @@ basic_regex<_CharT, _Traits>::__parse_ORD_CHAR(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp == __last && *__first == '$')
            return __first;
        // Not called inside a bracket
@@ -3333,7 +3295,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\')
@@ -3364,7 +3326,7 @@ basic_regex<_CharT, _Traits>::__parse_QUOTED_CHAR_ERE(_ForwardIterator __first,
 {
    if (__first != __last)
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        if (__temp != __last)
        {
            if (*__first == '\\')
@@ -3674,7 +3636,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
 {
    if (__first != __last && *__first != ']')
    {
-        _ForwardIterator __temp = _STD::next(__first);
+        _ForwardIterator __temp = next(__first);
        basic_string<_CharT> __start_range;
        if (__temp != __last && *__first == '[')
        {
@@ -3703,7 +3665,7 @@ basic_regex<_CharT, _Traits>::__parse_expression_term(_ForwardIterator __first,
        }
        if (__first != __last && *__first != ']')
        {
-            __temp = _STD::next(__first);
+            __temp = next(__first);
            if (__temp != __last && *__first == '-' && *__temp != ']')
            {
                // parse a range
@@ -3925,7 +3887,7 @@ basic_regex<_CharT, _Traits>::__parse_equivalence_class(_ForwardIterator __first
 #endif  // _LIBCPP_NO_EXCEPTIONS
        }
    }
-    __first = _STD::next(__temp, 2);
+    __first = next(__temp, 2);
    return __first;
 }

@@ -3954,7 +3916,7 @@ basic_regex<_CharT, _Traits>::__parse_character_class(_ForwardIterator __first,
        throw regex_error(regex_constants::error_brack);
 #endif  // _LIBCPP_NO_EXCEPTIONS
    __ml->__add_class(__class_type);
-    __first = _STD::next(__temp, 2);
+    __first = next(__temp, 2);
    return __first;
 }

@@ -3987,7 +3949,7 @@ basic_regex<_CharT, _Traits>::__parse_collating_symbol(_ForwardIterator __first,
        throw regex_error(regex_constants::error_collate);
 #endif  // _LIBCPP_NO_EXCEPTIONS
    }
-    __first = _STD::next(__temp, 2);
+    __first = next(__temp, 2);
    return __first;
 }

@@ -4121,6 +4083,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                basic_regex __exp;
                                __exp.__flags_ = __flags_;
                                __temp = __exp.__parse(++__temp, __last);
+                                __exp.__push_l_anchor();
                                __push_lookahead(_STD::move(__exp), false);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                if (__temp == __last || *__temp != ')')
@@ -4134,6 +4097,7 @@ basic_regex<_CharT, _Traits>::__parse_assertion(_ForwardIterator __first,
                                basic_regex __exp;
                                __exp.__flags_ = __flags_;
                                __temp = __exp.__parse(++__temp, __last);
+                                __exp.__push_l_anchor();
                                __push_lookahead(_STD::move(__exp), true);
 #ifndef _LIBCPP_NO_EXCEPTIONS
                                if (__temp == __last || *__temp != ')')
@@ -4608,14 +4572,6 @@ basic_regex<_CharT, _Traits>::__push_end_marked_subexpression(unsigned __sub)
    }
 }

-template <class _CharT, class _Traits>
-void
-basic_regex<_CharT, _Traits>::__push_l_anchor()
-{
-    __end_->first() = new __l_anchor<_CharT>(__end_->first());
-    __end_ = static_cast<__owns_one_state<_CharT>*>(__end_->first());
-}
-
 template <class _CharT, class _Traits>
 void
 basic_regex<_CharT, _Traits>::__push_r_anchor()
@@ -4727,9 +4683,6 @@ public:

    bool matched;

-    _LIBCPP_INLINE_VISIBILITY
-    /*constexpr*/ sub_match() : matched() {}
-
    _LIBCPP_INLINE_VISIBILITY
    difference_type length() const
        {return matched ? _STD::distance(this->first, this->second) : 0;}
@@ -5151,7 +5104,6 @@ private:
    value_type __unmatched_;
    value_type __prefix_;
    value_type __suffix_;
-    bool       __ready_;
 public:
    _BidirectionalIterator __position_start_;
    typedef const value_type&                                 const_reference;
@@ -5171,9 +5123,6 @@ public:
 //    match_results& operator=(match_results&& __m) = default;
 //    ~match_results() = default;

-    _LIBCPP_INLINE_VISIBILITY
-    bool ready() const {return __ready_;}
-
    // size:
    _LIBCPP_INLINE_VISIBILITY
    size_type size() const {return __matches_.size();}
@@ -5260,22 +5209,21 @@ public:
        __matches_.resize(__m.size());
        for (size_type __i = 0; __i < __matches_.size(); ++__i)
        {
-            __matches_[__i].first = _STD::next(__f, _STD::distance(__mf, __m[__i].first));
-            __matches_[__i].second = _STD::next(__f, _STD::distance(__mf, __m[__i].second));
+            __matches_[__i].first = next(__f, _STD::distance(__mf, __m[__i].first));
+            __matches_[__i].second = 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 = _STD::next(__f, _STD::distance(__mf, __m.prefix().first));
-        __prefix_.second = _STD::next(__f, _STD::distance(__mf, __m.prefix().second));
+        __prefix_.first = next(__f, _STD::distance(__mf, __m.prefix().first));
+        __prefix_.second = next(__f, _STD::distance(__mf, __m.prefix().second));
        __prefix_.matched = __m.prefix().matched;
-        __suffix_.first = _STD::next(__f, _STD::distance(__mf, __m.suffix().first));
-        __suffix_.second = _STD::next(__f, _STD::distance(__mf, __m.suffix().second));
+        __suffix_.first = next(__f, _STD::distance(__mf, __m.suffix().first));
+        __suffix_.second = next(__f, _STD::distance(__mf, __m.suffix().second));
        __suffix_.matched = __m.suffix().matched;
        if (!__no_update_pos)
            __position_start_ = __prefix_.first;
-        __ready_ = __m.ready();
    }

 private:
@@ -5306,8 +5254,7 @@ match_results<_BidirectionalIterator, _Allocator>::match_results(
      __unmatched_(),
      __prefix_(),
      __suffix_(),
-      __position_start_(),
-      __ready_(false)
+      __position_start_()
 {
 }

@@ -5327,7 +5274,6 @@ match_results<_BidirectionalIterator, _Allocator>::__init(unsigned __s,
    __suffix_ = __unmatched_;
    if (!__no_update_pos)
        __position_start_ = __prefix_.first;
-    __ready_ = true;
 }

 template <class _BidirectionalIterator, class _Allocator>
@@ -5433,7 +5379,6 @@ match_results<_BidirectionalIterator, _Allocator>::swap(match_results& __m)
    swap(__prefix_, __m.__prefix_);
    swap(__suffix_, __m.__suffix_);
    swap(__position_start_, __m.__position_start_);
-    swap(__ready_, __m.__ready_);
 }

 typedef match_results<const char*>             cmatch;
@@ -5446,13 +5391,10 @@ bool
 operator==(const match_results<_BidirectionalIterator, _Allocator>& __x,
           const match_results<_BidirectionalIterator, _Allocator>& __y)
 {
-    if (__x.__ready_ != __y.__ready_)
-        return false;
-    if (!__x.__ready_)
-        return true;
    return __x.__matches_ == __y.__matches_ &&
           __x.__prefix_ == __y.__prefix_ &&
-           __x.__suffix_ == __y.__suffix_;
+           __x.__suffix_ == __y.__suffix_ &&
+           __x.__position_start_ == __y.__position_start_;
 }

 template <class _BidirectionalIterator, class _Allocator>
@@ -5481,7 +5423,7 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start_ecma(
        const _CharT* __first, const _CharT* __last,
        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
    vector<__state> __states;
    ptrdiff_t __j = 0;
@@ -5498,7 +5440,6 @@ basic_regex<_CharT, _Traits>::__match_at_start_ecma(
        __states.back().__loop_data_.resize(__loop_count());
        __states.back().__node_ = __st;
        __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
        bool __matched = false;
        do
        {
@@ -5547,7 +5488,7 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
        const _CharT* __first, const _CharT* __last,
        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
    deque<__state> __states;
    ptrdiff_t __highest_j = 0;
@@ -5563,7 +5504,6 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_nosubs(
        __states.back().__loop_data_.resize(__loop_count());
        __states.back().__node_ = __st;
        __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
        bool __matched = false;
        do
        {
@@ -5625,7 +5565,7 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
        const _CharT* __first, const _CharT* __last,
        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
    vector<__state> __states;
    __state __best_state;
@@ -5644,7 +5584,6 @@ basic_regex<_CharT, _Traits>::__match_at_start_posix_subs(
        __states.back().__loop_data_.resize(__loop_count());
        __states.back().__node_ = __st;
        __states.back().__flags_ = __flags;
-        __states.back().__at_first_ = __at_first;
        const _CharT* __current = __first;
        bool __matched = false;
        do
@@ -5710,13 +5649,13 @@ bool
 basic_regex<_CharT, _Traits>::__match_at_start(
        const _CharT* __first, const _CharT* __last,
        match_results<const _CharT*, _Allocator>& __m,
-        regex_constants::match_flag_type __flags, bool __at_first) const
+        regex_constants::match_flag_type __flags) const
 {
    if ((__flags_ & 0x1F0) == ECMAScript)
-        return __match_at_start_ecma(__first, __last, __m, __flags, __at_first);
+        return __match_at_start_ecma(__first, __last, __m, __flags);
    if (mark_count() == 0)
-        return __match_at_start_posix_nosubs(__first, __last, __m, __flags, __at_first);
-    return __match_at_start_posix_subs(__first, __last, __m, __flags, __at_first);
+        return __match_at_start_posix_nosubs(__first, __last, __m, __flags);
+    return __match_at_start_posix_subs(__first, __last, __m, __flags);
 }

 template <class _CharT, class _Traits>
@@ -5727,9 +5666,11 @@ basic_regex<_CharT, _Traits>::__search(
        match_results<const _CharT*, _Allocator>& __m,
        regex_constants::match_flag_type __flags) const
 {
+    if (__left_anchor_)
+        __flags |= regex_constants::match_continuous;
    __m.__init(1 + mark_count(), __first, __last,
                                    __flags & regex_constants::__no_update_pos);
-    if (__match_at_start(__first, __last, __m, __flags, true))
+    if (__match_at_start(__first, __last, __m, __flags))
    {
        __m.__prefix_.second = __m[0].first;
        __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
@@ -5743,7 +5684,7 @@ basic_regex<_CharT, _Traits>::__search(
        for (++__first; __first != __last; ++__first)
        {
            __m.__matches_.assign(__m.size(), __m.__unmatched_);
-            if (__match_at_start(__first, __last, __m, __flags, false))
+            if (__match_at_start(__first, __last, __m, __flags))
            {
                __m.__prefix_.second = __m[0].first;
                __m.__prefix_.matched = __m.__prefix_.first != __m.__prefix_.second;
--- a/include/scoped_allocator
+++ b/include/scoped_allocator
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/set
+++ b/include/set
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/sstream
+++ b/include/sstream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -451,7 +451,7 @@ basic_stringbuf<_CharT, _Traits, _Allocator>::overflow(int_type __c)
            }
 #endif  // _LIBCPP_NO_EXCEPTIONS
        }
-        __hm_ = _STD::max(this->pptr() + 1, __hm_);
+        __hm_ = max(this->pptr() + 1, __hm_);
        if (__mode_ & ios_base::in)
        {
            char_type* __p = const_cast<char_type*>(__str_.data());
--- a/include/stack
+++ b/include/stack
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/stdexcept
+++ b/include/stdexcept
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/streambuf
+++ b/include/streambuf
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/string
+++ b/include/string
@@ -200,13 +200,13 @@ public:
    basic_string& replace(size_type pos, size_type n1, const_pointer s, size_type n2);
    basic_string& replace(size_type pos, size_type n1, const_pointer s);
    basic_string& replace(size_type pos, size_type n1, size_type n2, value_type c);
-    basic_string& replace(const_iterator i1, const_iterator i2, const basic_string& str);
-    basic_string& replace(const_iterator i1, const_iterator i2, const_pointer s, size_type n);
-    basic_string& replace(const_iterator i1, const_iterator i2, const_pointer s);
-    basic_string& replace(const_iterator i1, const_iterator i2, size_type n, value_type c);
+    basic_string& replace(iterator i1, iterator i2, const basic_string& str);
+    basic_string& replace(iterator i1, iterator i2, const_pointer s, size_type n);
+    basic_string& replace(iterator i1, iterator i2, const_pointer s);
+    basic_string& replace(iterator i1, iterator i2, size_type n, value_type c);
    template<class InputIterator>
-        basic_string& replace(const_iterator i1, const_iterator i2, InputIterator j1, InputIterator j2);
-    basic_string& replace(const_iterator i1, const_iterator i2, initializer_list<value_type>);
+        basic_string& replace(iterator i1, iterator i2, InputIterator j1, InputIterator j2);
+    basic_string& replace(iterator i1, iterator i2, initializer_list<value_type>);

    size_type copy(pointer s, size_type n, size_type pos = 0) const;
    basic_string substr(size_type pos = 0, size_type n = npos) const;
@@ -941,13 +941,12 @@ public:
    typedef _Traits                                      traits_type;
    typedef typename traits_type::char_type              value_type;
    typedef _Allocator                                   allocator_type;
-    typedef allocator_traits<allocator_type>             __alloc_traits;
-    typedef typename __alloc_traits::size_type           size_type;
-    typedef typename __alloc_traits::difference_type     difference_type;
+    typedef typename allocator_type::size_type           size_type;
+    typedef typename allocator_type::difference_type     difference_type;
    typedef typename allocator_type::reference           reference;
    typedef typename allocator_type::const_reference     const_reference;
-    typedef typename __alloc_traits::pointer             pointer;
-    typedef typename __alloc_traits::const_pointer       const_pointer;
+    typedef typename allocator_type::pointer             pointer;
+    typedef typename allocator_type::const_pointer       const_pointer;
 #ifdef _LIBCPP_DEBUG
    typedef __debug_iter<basic_string, pointer>          iterator;
    typedef __debug_iter<basic_string, const_pointer>    const_iterator;
@@ -1028,46 +1027,34 @@ private:
 public:
    static const size_type npos = -1;

-    _LIBCPP_INLINE_VISIBILITY basic_string();
-    _LIBCPP_INLINE_VISIBILITY explicit basic_string(const allocator_type& __a);
+    basic_string();
+    explicit basic_string(const allocator_type& __a);
    basic_string(const basic_string& __str);
    basic_string(const basic_string& __str, const allocator_type& __a);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(basic_string&& __str);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(basic_string&& __str, const allocator_type& __a);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY basic_string(const_pointer __s);
-    _LIBCPP_INLINE_VISIBILITY
+    basic_string(const_pointer __s);
    basic_string(const_pointer __s, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(const_pointer __s, size_type __n);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(const_pointer __s, size_type __n, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(size_type __n, value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(size_type __n, value_type __c, const allocator_type& __a);
    basic_string(const basic_string& __str, size_type __pos, size_type __n = npos,
                 const allocator_type& __a = allocator_type());
    template<class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
        basic_string(_InputIterator __first, _InputIterator __last);
    template<class _InputIterator>
-        _LIBCPP_INLINE_VISIBILITY
        basic_string(_InputIterator __first, _InputIterator __last, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(initializer_list<value_type> __il);
-    _LIBCPP_INLINE_VISIBILITY
    basic_string(initializer_list<value_type> __il, const allocator_type& __a);

    ~basic_string();

-    basic_string& operator=(const basic_string& __str);
+    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const basic_string& __str) {return assign(__str);}
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string& operator=(basic_string&& __str);
+    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(basic_string&& __str) {swap(__str); return *this;}
 #endif
    _LIBCPP_INLINE_VISIBILITY basic_string& operator=(const_pointer __s)         {return assign(__s);}
    basic_string& operator=(value_type __c);
@@ -1098,7 +1085,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY size_type size() const
        {return __is_long() ? __get_long_size() : __get_short_size();}
    _LIBCPP_INLINE_VISIBILITY size_type length() const {return size();}
-    _LIBCPP_INLINE_VISIBILITY size_type max_size() const;
+    size_type max_size() const;
    _LIBCPP_INLINE_VISIBILITY size_type capacity() const
        {return (__is_long() ? __get_long_cap() : __min_cap) - 1;}

@@ -1108,7 +1095,6 @@ public:
    void reserve(size_type res_arg = 0);
    _LIBCPP_INLINE_VISIBILITY
    void shrink_to_fit() {reserve();}
-    _LIBCPP_INLINE_VISIBILITY
    void clear();
    _LIBCPP_INLINE_VISIBILITY bool empty() const {return size() == 0;}

@@ -1123,7 +1109,6 @@ public:
    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(value_type __c)            {push_back(__c); return *this;}
    _LIBCPP_INLINE_VISIBILITY basic_string& operator+=(initializer_list<value_type> __il) {return append(__il);}

-    _LIBCPP_INLINE_VISIBILITY
    basic_string& append(const basic_string& __str);
    basic_string& append(const basic_string& __str, size_type __pos, size_type __n);
    basic_string& append(const_pointer __s, size_type __n);
@@ -1148,14 +1133,12 @@ public:
    basic_string& append(initializer_list<value_type> __il) {return append(__il.begin(), __il.size());}

    void push_back(value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
    void pop_back();
-    _LIBCPP_INLINE_VISIBILITY reference       front();
-    _LIBCPP_INLINE_VISIBILITY const_reference front() const;
-    _LIBCPP_INLINE_VISIBILITY reference       back();
-    _LIBCPP_INLINE_VISIBILITY const_reference back() const;
+    reference       front();
+    const_reference front() const;
+    reference       back();
+    const_reference back() const;

-    _LIBCPP_INLINE_VISIBILITY
    basic_string& assign(const basic_string& __str);
    basic_string& assign(const basic_string& __str, size_type __pos, size_type __n);
    basic_string& assign(const_pointer __s, size_type __n);
@@ -1179,14 +1162,12 @@ public:
    _LIBCPP_INLINE_VISIBILITY
    basic_string& assign(initializer_list<value_type> __il) {return assign(__il.begin(), __il.size());}

-    _LIBCPP_INLINE_VISIBILITY
    basic_string& insert(size_type __pos1, const basic_string& __str);
    basic_string& insert(size_type __pos1, const basic_string& __str, size_type __pos2, size_type __n);
    basic_string& insert(size_type __pos, const_pointer __s, size_type __n);
    basic_string& insert(size_type __pos, const_pointer __s);
    basic_string& insert(size_type __pos, size_type __n, value_type __c);
    iterator      insert(const_iterator __pos, value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
    iterator      insert(const_iterator __pos, size_type __n, value_type __c);
    template<class _InputIterator>
        typename enable_if
@@ -1208,41 +1189,32 @@ public:
                    {return insert(__pos, __il.begin(), __il.end());}

    basic_string& erase(size_type __pos = 0, size_type __n = npos);
-    _LIBCPP_INLINE_VISIBILITY
    iterator      erase(const_iterator __pos);
-    _LIBCPP_INLINE_VISIBILITY
    iterator      erase(const_iterator __first, const_iterator __last);

-    _LIBCPP_INLINE_VISIBILITY
    basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str);
    basic_string& replace(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2);
    basic_string& replace(size_type __pos, size_type __n1, const_pointer __s, size_type __n2);
    basic_string& replace(size_type __pos, size_type __n1, const_pointer __s);
    basic_string& replace(size_type __pos, size_type __n1, size_type __n2, value_type __c);
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, const basic_string& __str);
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, const_pointer __s, size_type __n);
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, const_pointer __s);
-    _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c);
+    basic_string& replace(iterator __i1, iterator __i2, const basic_string& __str);
+    basic_string& replace(iterator __i1, iterator __i2, const_pointer __s, size_type __n);
+    basic_string& replace(iterator __i1, iterator __i2, const_pointer __s);
+    basic_string& replace(iterator __i1, iterator __i2, size_type __n, value_type __c);
    template<class _InputIterator>
        typename enable_if
        <
            __is_input_iterator<_InputIterator>::value,
            basic_string&
        >::type
-        replace(const_iterator __i1, const_iterator __i2, _InputIterator __j1, _InputIterator __j2);
+        replace(iterator __i1, iterator __i2, _InputIterator __j1, _InputIterator __j2);
    _LIBCPP_INLINE_VISIBILITY
-    basic_string& replace(const_iterator __i1, const_iterator __i2, initializer_list<value_type> __il)
+    basic_string& replace(iterator __i1, iterator __i2, initializer_list<value_type> __il)
        {return replace(__i1, __i2, __il.begin(), __il.end());}

    size_type copy(pointer __s, size_type __n, size_type __pos = 0) const;
-    _LIBCPP_INLINE_VISIBILITY
    basic_string substr(size_type __pos = 0, size_type __n = npos) const;

-    _LIBCPP_INLINE_VISIBILITY
    void swap(basic_string& __str);

    _LIBCPP_INLINE_VISIBILITY const_pointer c_str() const {return data();}
@@ -1250,62 +1222,44 @@ public:

    _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const {return __alloc();}

-    _LIBCPP_INLINE_VISIBILITY
    size_type find(const basic_string& __str, size_type __pos = 0) const;
    size_type find(const_pointer __s, size_type __pos, size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find(const_pointer __s, size_type __pos = 0) const;
    size_type find(value_type __c, size_type __pos = 0) const;

-    _LIBCPP_INLINE_VISIBILITY
    size_type rfind(const basic_string& __str, size_type __pos = npos) const;
    size_type rfind(const_pointer __s, size_type __pos, size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type rfind(const_pointer __s, size_type __pos = npos) const;
    size_type rfind(value_type __c, size_type __pos = npos) const;

-    _LIBCPP_INLINE_VISIBILITY
    size_type find_first_of(const basic_string& __str, size_type __pos = 0) const;
    size_type find_first_of(const_pointer __s, size_type __pos, size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_first_of(const_pointer __s, size_type __pos = 0) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_first_of(value_type __c, size_type __pos = 0) const;

-    _LIBCPP_INLINE_VISIBILITY
    size_type find_last_of(const basic_string& __str, size_type __pos = npos) const;
    size_type find_last_of(const_pointer __s, size_type __pos, size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_last_of(const_pointer __s, size_type __pos = npos) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_last_of(value_type __c, size_type __pos = npos) const;

-    _LIBCPP_INLINE_VISIBILITY
    size_type find_first_not_of(const basic_string& __str, size_type __pos = 0) const;
    size_type find_first_not_of(const_pointer __s, size_type __pos, size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_first_not_of(const_pointer __s, size_type __pos = 0) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_first_not_of(value_type __c, size_type __pos = 0) const;

-    _LIBCPP_INLINE_VISIBILITY
    size_type find_last_not_of(const basic_string& __str, size_type __pos = npos) const;
    size_type find_last_not_of(const_pointer __s, size_type __pos, size_type __n) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_last_not_of(const_pointer __s, size_type __pos = npos) const;
-    _LIBCPP_INLINE_VISIBILITY
    size_type find_last_not_of(value_type __c, size_type __pos = npos) const;

-    _LIBCPP_INLINE_VISIBILITY
    int compare(const basic_string& __str) const;
-    _LIBCPP_INLINE_VISIBILITY
    int compare(size_type __pos1, size_type __n1, const basic_string& __str) const;
    int compare(size_type __pos1, size_type __n1, const basic_string& __str, size_type __pos2, size_type __n2) const;
    int compare(const_pointer __s) const;
    int compare(size_type __pos1, size_type __n1, const_pointer __s) const;
    int compare(size_type __pos1, size_type __n1, const_pointer __s, size_type __n2) const;

-    _LIBCPP_INLINE_VISIBILITY bool __invariants() const;
+    bool __invariants() const;
 private:
    _LIBCPP_INLINE_VISIBILITY allocator_type&       __alloc()       {return __r_.second();}
    _LIBCPP_INLINE_VISIBILITY const allocator_type& __alloc() const {return __r_.second();}
@@ -1383,53 +1337,10 @@ private:
                               size_type __n_copy,  size_type __n_del,
                               size_type __n_add, const_pointer __p_new_stuff);

-    _LIBCPP_INLINE_VISIBILITY
    void __erase_to_end(size_type __pos);

-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const basic_string& __str)
-        {__copy_assign_alloc(__str, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_copy_assignment::value>());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const basic_string& __str, true_type)
-        {
-            if (__alloc() != __str.__alloc())
-            {
-                clear();
-                shrink_to_fit();
-            }
-            __alloc() = __str.__alloc();
-        }
-
-    _LIBCPP_INLINE_VISIBILITY
-    void __copy_assign_alloc(const basic_string& __str, false_type)
-        {}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign(basic_string& __str, false_type);
-    _LIBCPP_INLINE_VISIBILITY
-    void __move_assign(basic_string& __str, true_type);
-#endif
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void __swap_alloc(allocator_type& __x, allocator_type& __y)
-        {__swap_alloc(__x, __y, integral_constant<bool,
-                      __alloc_traits::propagate_on_container_swap::value>());}
-
-    _LIBCPP_INLINE_VISIBILITY
-    static void __swap_alloc(allocator_type& __x, allocator_type& __y, true_type)
-        {
-            using _STD::swap;
-            swap(__x, __y);
-        }
-    _LIBCPP_INLINE_VISIBILITY
-    static void __swap_alloc(allocator_type& __x, allocator_type& __y, false_type)
-        {}
-
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_iterators_past(size_type);
+    void __invalidate_all_iterators();
+    void __invalidate_iterators_past(size_type);

    friend basic_string operator+<>(const basic_string&, const basic_string&);
    friend basic_string operator+<>(const value_type*, const basic_string&);
@@ -1521,7 +1432,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(const_pointer __s, size_type _
    else
    {
        size_type __cap = __recommend(__reserve);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc().allocate(__cap+1);
        __set_long_pointer(__p);
        __set_long_cap(__cap+1);
        __set_long_size(__sz);
@@ -1545,7 +1456,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(const_pointer __s, size_type _
    else
    {
        size_type __cap = __recommend(__sz);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc().allocate(__cap+1);
        __set_long_pointer(__p);
        __set_long_cap(__cap+1);
        __set_long_size(__sz);
@@ -1598,7 +1509,7 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(const_pointer __s, size_

 template <class _CharT, class _Traits, class _Allocator>
 basic_string<_CharT, _Traits, _Allocator>::basic_string(const basic_string& __str)
-    : __r_(__alloc_traits::select_on_container_copy_construction(__str.__alloc()))
+    : __r_(__str.__alloc())
 {
    if (!__str.__is_long())
        __r_.first().__r = __str.__r_.first().__r;
@@ -1632,12 +1543,8 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str)
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>::basic_string(basic_string&& __str, const allocator_type& __a)
-    : __r_(__a)
+    : __r_(__str.__r_.first(), __a)
 {
-    if (__a == __str.__alloc() || !__str.__is_long())
-        __r_.first().__r = __str.__r_.first().__r;
-    else
-        __init(__str.__get_long_pointer(), __str.__get_long_size());
    __str.__zero();
 #ifdef _LIBCPP_DEBUG
    __str.__invalidate_all_iterators();
@@ -1661,7 +1568,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(size_type __n, value_type __c)
    else
    {
        size_type __cap = __recommend(__n);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc().allocate(__cap+1);
        __set_long_pointer(__p);
        __set_long_cap(__cap+1);
        __set_long_size(__n);
@@ -1718,7 +1625,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(_InputIterator __first, _Input
    catch (...)
    {
        if (__is_long())
-            __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+            __alloc().deallocate(__get_long_pointer(), __get_long_cap());
        throw;
    }
 #endif  // _LIBCPP_NO_EXCEPTIONS
@@ -1745,7 +1652,7 @@ basic_string<_CharT, _Traits, _Allocator>::__init(_ForwardIterator __first, _For
    else
    {
        size_type __cap = __recommend(__sz);
-        __p = __alloc_traits::allocate(__alloc(), __cap+1);
+        __p = __alloc().allocate(__cap+1);
        __set_long_pointer(__p);
        __set_long_cap(__cap+1);
        __set_long_size(__sz);
@@ -1789,11 +1696,12 @@ basic_string<_CharT, _Traits, _Allocator>::basic_string(initializer_list<value_t
 }

 template <class _CharT, class _Traits, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>::~basic_string()
 {
    __invalidate_all_iterators();
    if (__is_long())
-        __alloc_traits::deallocate(__alloc(), __get_long_pointer(), __get_long_cap());
+        __alloc().deallocate(__get_long_pointer(), __get_long_cap());
 }

 template <class _CharT, class _Traits, class _Allocator>
@@ -1809,7 +1717,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
    size_type __cap = __old_cap < __ms / 2 - __alignment ?
                          __recommend(_STD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                          __ms - 1;
-    pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
+    pointer __p = __alloc().allocate(__cap+1);
    __invalidate_all_iterators();
    if (__n_copy != 0)
        traits_type::copy(__p, __old_p, __n_copy);
@@ -1819,7 +1727,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by_and_replace
    if (__sec_cp_sz != 0)
        traits_type::copy(__p + __n_copy + __n_add, __old_p + __n_copy + __n_del, __sec_cp_sz);
    if (__old_cap+1 != __min_cap)
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
+        __alloc().deallocate(__old_p, __old_cap+1);
    __set_long_pointer(__p);
    __set_long_cap(__cap+1);
    __old_sz = __n_copy + __n_add + __sec_cp_sz;
@@ -1839,7 +1747,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
    size_type __cap = __old_cap < __ms / 2 - __alignment ?
                          __recommend(_STD::max(__old_cap + __delta_cap, 2 * __old_cap)) :
                          __ms - 1;
-    pointer __p = __alloc_traits::allocate(__alloc(), __cap+1);
+    pointer __p = __alloc().allocate(__cap+1);
    __invalidate_all_iterators();
    if (__n_copy != 0)
        traits_type::copy(__p, __old_p, __n_copy);
@@ -1847,7 +1755,7 @@ basic_string<_CharT, _Traits, _Allocator>::__grow_by(size_type __old_cap, size_t
    if (__sec_cp_sz != 0)
        traits_type::copy(__p + __n_copy + __n_add, __old_p + __n_copy + __n_del, __sec_cp_sz);
    if (__old_cap+1 != __min_cap)
-        __alloc_traits::deallocate(__alloc(), __old_p, __old_cap+1);
+        __alloc().deallocate(__old_p, __old_cap+1);
    __set_long_pointer(__p);
    __set_long_cap(__cap+1);
 }
@@ -1918,54 +1826,6 @@ basic_string<_CharT, _Traits, _Allocator>::operator=(value_type __c)
    return *this;
 }

-template <class _CharT, class _Traits, class _Allocator>
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::operator=(const basic_string& __str)
-{
-    if (this != &__str)
-    {
-        __copy_assign_alloc(__str);
-        assign(__str);
-    }
-    return *this;
-}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, false_type)
-{
-    if (__alloc() != __str.__alloc())
-        assign(__str);
-    else
-        __move_assign(__str, true_type());
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-void
-basic_string<_CharT, _Traits, _Allocator>::__move_assign(basic_string& __str, true_type)
-{
-    clear();
-    shrink_to_fit();
-    __r_ = _STD::move(__str.__r_);
-    __str.__zero();
-}
-
-template <class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
-basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::operator=(basic_string&& __str)
-{
-    __move_assign(__str, integral_constant<bool,
-          __alloc_traits::propagate_on_container_move_assignment::value>());
-    return *this;
-}
-
-#endif
-
 template <class _CharT, class _Traits, class _Allocator>
 template<class _InputIterator>
 typename enable_if
@@ -2447,7 +2307,7 @@ typename enable_if
    __is_input_iterator<_InputIterator>::value,
    basic_string<_CharT, _Traits, _Allocator>&
 >::type
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2,
+basic_string<_CharT, _Traits, _Allocator>::replace(iterator __i1, iterator __i2,
                                                   _InputIterator __j1, _InputIterator __j2)
 {
    for (; true; ++__i1, ++__j1)
@@ -2463,7 +2323,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
            erase(__i1, __i2);
            break;
        }
-        traits_type::assign(const_cast<value_type&>(*__i1), *__j1);
+        traits_type::assign(*__i1, *__j1);
    }
    return *this;
 }
@@ -2500,7 +2360,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(size_type __pos, size_type __
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const basic_string& __str)
+basic_string<_CharT, _Traits, _Allocator>::replace(iterator __i1, iterator __i2, const basic_string& __str)
 {
    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1),
                   __str.data(), __str.size());
@@ -2509,7 +2369,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const_pointer __s, size_type __n)
+basic_string<_CharT, _Traits, _Allocator>::replace(iterator __i1, iterator __i2, const_pointer __s, size_type __n)
 {
    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s, __n);
 }
@@ -2517,7 +2377,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, const_pointer __s)
+basic_string<_CharT, _Traits, _Allocator>::replace(iterator __i1, iterator __i2, const_pointer __s)
 {
    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __s);
 }
@@ -2525,7 +2385,7 @@ basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_it
 template <class _CharT, class _Traits, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 basic_string<_CharT, _Traits, _Allocator>&
-basic_string<_CharT, _Traits, _Allocator>::replace(const_iterator __i1, const_iterator __i2, size_type __n, value_type __c)
+basic_string<_CharT, _Traits, _Allocator>::replace(iterator __i1, iterator __i2, size_type __n, value_type __c)
 {
    return replace(static_cast<size_type>(__i1 - begin()), static_cast<size_type>(__i2 - __i1), __n, __c);
 }
@@ -2652,7 +2512,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 typename basic_string<_CharT, _Traits, _Allocator>::size_type
 basic_string<_CharT, _Traits, _Allocator>::max_size() const
 {
-    size_type __m = __alloc_traits::max_size(__alloc());
+    size_type __m = __alloc().max_size();
 #if _LIBCPP_BIG_ENDIAN
    return (__m <= ~__long_mask ? __m : __m/2) - 1;
 #else
@@ -2684,14 +2544,14 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
        else
        {
            if (__res_arg > __cap)
-                __new_data = __alloc_traits::allocate(__alloc(), __res_arg+1);
+                __new_data = __alloc().allocate(__res_arg+1);
            else
            {
            #ifndef _LIBCPP_NO_EXCEPTIONS
                try
                {
            #endif  // _LIBCPP_NO_EXCEPTIONS
-                    __new_data = __alloc_traits::allocate(__alloc(), __res_arg+1);
+                    __new_data = __alloc().allocate(__res_arg+1);
            #ifndef _LIBCPP_NO_EXCEPTIONS
                }
                catch (...)
@@ -2709,7 +2569,7 @@ basic_string<_CharT, _Traits, _Allocator>::reserve(size_type __res_arg)
        }
        traits_type::copy(__new_data, __p, size()+1);
        if (__was_long)
-            __alloc_traits::deallocate(__alloc(), __p, __cap+1);
+            __alloc().deallocate(__p, __cap+1);
        if (__now_long)
        {
            __set_long_cap(__res_arg+1);
@@ -2831,8 +2691,7 @@ _LIBCPP_INLINE_VISIBILITY inline
 void
 basic_string<_CharT, _Traits, _Allocator>::swap(basic_string& __str)
 {
-    _STD::swap(__r_.first(), __str.__r_.first());
-    __swap_alloc(__alloc(), __str.__alloc());
+    __r_.swap(__str.__r_);
 #ifdef _LIBCPP_DEBUG
    __invalidate_all_iterators();
    __str.__invalidate_all_iterators();
@@ -3251,7 +3110,6 @@ basic_string<_CharT, _Traits, _Allocator>::compare(size_type __pos1, size_type _
 // __invariants

 template<class _CharT, class _Traits, class _Allocator>
-_LIBCPP_INLINE_VISIBILITY inline
 bool
 basic_string<_CharT, _Traits, _Allocator>::__invariants() const
 {
@@ -3643,6 +3501,10 @@ swap(basic_string<_CharT, _Traits, _Allocator>& __lhs, basic_string<_CharT, _Tra
    __lhs.swap(__rhs);
 }

+template<class _CharT, class _Traits, class _Allocator>
+struct __is_zero_default_constructible<basic_string<_CharT, _Traits, _Allocator> >
+    : public integral_constant<bool, __is_zero_default_constructible<_Allocator>::value> {};
+
 #ifndef _LIBCPP_HAS_NO_UNICODE_CHARS

 typedef basic_string<char16_t> u16string;
@@ -3763,12 +3625,12 @@ extern template
 extern template
    enable_if<__is_input_iterator<char const*>::value, string&>::type
    string::
-    replace<char const*>(string::const_iterator, string::const_iterator, char const*, char const*);
+    replace<char const*>(string::iterator, string::iterator, char const*, char const*);

 extern template
    enable_if<__is_input_iterator<wchar_t const*>::value, wstring&>::type
    wstring::
-    replace<wchar_t const*>(wstring::const_iterator, wstring::const_iterator, wchar_t const*, wchar_t const*);
+    replace<wchar_t const*>(wstring::iterator, wstring::iterator, wchar_t const*, wchar_t const*);

 extern template
    enable_if<__is_forward_iterator<wchar_t*>::value, wstring&>::type
--- a/include/strstream
+++ b/include/strstream
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/system_error
+++ b/include/system_error
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/tgmath.h
+++ b/include/tgmath.h
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/thread
+++ b/include/thread
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -253,8 +253,13 @@ class _LIBCPP_VISIBLE thread
 {
    pthread_t __t_;

+#ifndef _LIBCPP_HAS_NO_DELETED_FUNCTIONS
+    thread(const thread&) = delete;
+    thread& operator=(const thread&) = delete;
+#else  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
    thread(const thread&);
    thread& operator=(const thread&);
+#endif  // _LIBCPP_HAS_NO_DELETED_FUNCTIONS
 public:
    typedef __thread_id id;
    typedef pthread_t native_handle_type;
@@ -297,7 +302,7 @@ public:

 class __assoc_sub_state;

-class _LIBCPP_HIDDEN __thread_struct_imp;
+class __thread_struct_imp;

 class __thread_struct
 {
@@ -406,10 +411,10 @@ sleep_until(const chrono::time_point<_Clock, _Duration>& __t)
 template <class _Duration>
 inline _LIBCPP_INLINE_VISIBILITY
 void
-sleep_until(const chrono::time_point<chrono::steady_clock, _Duration>& __t)
+sleep_until(const chrono::time_point<chrono::monotonic_clock, _Duration>& __t)
 {
    using namespace chrono;
-    sleep_for(__t - steady_clock::now());
+    sleep_for(__t - monotonic_clock::now());
 }

 inline _LIBCPP_INLINE_VISIBILITY
--- a/include/tuple
+++ b/include/tuple
@@ -74,8 +74,11 @@ const unspecified ignore;
 template <class... T> tuple<V...>  make_tuple(T&&...);
 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);
-  
+template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, const tuple<U...>&);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, const tuple<U...>&);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(const tuple<T...>&, tuple<U...>&&);
+template <class... T, class... U> tuple<T..., U...> tuple_cat(tuple<T...>&&, tuple<U...>&&);
+
 // 20.4.1.4, tuple helper classes:
 template <class T> class tuple_size; // undefined
 template <class... T> class tuple_size<tuple<T...>>;
@@ -85,7 +88,6 @@ 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...>&);
 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...>&);
@@ -120,7 +122,13 @@ _LIBCPP_BEGIN_NAMESPACE_STD
 // tuple_size

 template <class ..._Tp>
-class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
+class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...>>
+    : public integral_constant<size_t, sizeof...(_Tp)>
+{
+};
+
+template <class ..._Tp>
+class _LIBCPP_VISIBLE tuple_size<const tuple<_Tp...>>
    : public integral_constant<size_t, sizeof...(_Tp)>
 {
 };
@@ -128,10 +136,17 @@ class _LIBCPP_VISIBLE tuple_size<tuple<_Tp...> >
 // tuple_element

 template <size_t _Ip, class ..._Tp>
-class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...> >
+class _LIBCPP_VISIBLE tuple_element<_Ip, tuple<_Tp...>>
 {
 public:
-    typedef typename tuple_element<_Ip, __tuple_types<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
+};
+
+template <size_t _Ip, class ..._Tp>
+class _LIBCPP_VISIBLE tuple_element<_Ip, const tuple<_Tp...>>
+{
+public:
+    typedef const typename tuple_element<_Ip, __tuple_types<_Tp...>>::type type;
 };

 // __tuple_leaf
@@ -373,7 +388,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
    template <class _Tuple,
              class = typename enable_if
                      <
-                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
+                         __tuple_convertible<_Tuple, tuple<_Tp...>>::value
                      >::type
             >
        _LIBCPP_INLINE_VISIBILITY
@@ -385,7 +400,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
    template <class _Alloc, class _Tuple,
              class = typename enable_if
                      <
-                         __tuple_convertible<_Tuple, tuple<_Tp...> >::value
+                         __tuple_convertible<_Tuple, tuple<_Tp...>>::value
                      >::type
             >
        _LIBCPP_INLINE_VISIBILITY
@@ -400,7 +415,7 @@ struct __tuple_impl<__tuple_indices<_Indx...>, _Tp...>
        _LIBCPP_INLINE_VISIBILITY
        typename enable_if
        <
-            __tuple_assignable<_Tuple, tuple<_Tp...> >::value,
+            __tuple_assignable<_Tuple, tuple<_Tp...>>::value,
            __tuple_impl&
        >::type
        operator=(_Tuple&& __t)
@@ -425,11 +440,9 @@ class _LIBCPP_VISIBLE tuple
    base base_;

    template <size_t _Jp, class ..._Up> friend
-        typename tuple_element<_Jp, tuple<_Up...> >::type& get(tuple<_Up...>&);
+        typename tuple_element<_Jp, tuple<_Up...>>::type& get(tuple<_Up...>&);
    template <size_t _Jp, class ..._Up> friend
-        const typename tuple_element<_Jp, tuple<_Up...> >::type& get(const tuple<_Up...>&);
-    template <size_t _Jp, class ..._Up> friend
-        typename tuple_element<_Jp, tuple<_Up...> >::type&& get(tuple<_Up...>&&);
+        const typename tuple_element<_Jp, tuple<_Up...>>::type& get(const tuple<_Up...>&);
 public:

    _LIBCPP_INLINE_VISIBILITY
@@ -567,32 +580,22 @@ swap(tuple<_Tp...>& __t, tuple<_Tp...>& __u) {__t.swap(__u);}

 template <size_t _Ip, class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-typename tuple_element<_Ip, tuple<_Tp...> >::type&
+typename tuple_element<_Ip, tuple<_Tp...>>::type&
 get(tuple<_Tp...>& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
    return static_cast<__tuple_leaf<_Ip, type>&>(__t.base_).get();
 }

 template <size_t _Ip, class ..._Tp>
 inline _LIBCPP_INLINE_VISIBILITY
-const typename tuple_element<_Ip, tuple<_Tp...> >::type&
+const typename tuple_element<_Ip, tuple<_Tp...>>::type&
 get(const tuple<_Tp...>& __t)
 {
-    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
+    typedef typename tuple_element<_Ip, tuple<_Tp...>>::type type;
    return static_cast<const __tuple_leaf<_Ip, type>&>(__t.base_).get();
 }

-template <size_t _Ip, class ..._Tp>
-inline _LIBCPP_INLINE_VISIBILITY
-typename tuple_element<_Ip, tuple<_Tp...> >::type&&
-get(tuple<_Tp...>&& __t)
-{
-    typedef typename tuple_element<_Ip, tuple<_Tp...> >::type type;
-    return static_cast<type&&>(
-             static_cast<__tuple_leaf<_Ip, type>&&>(__t.base_).get());
-}
-
 // tie

 template <class ..._Tp>
@@ -627,7 +630,7 @@ struct ___make_tuple_return
 };

 template <class _Tp>
-struct ___make_tuple_return<reference_wrapper<_Tp> >
+struct ___make_tuple_return<reference_wrapper<_Tp>>
 {
    typedef _Tp& type;
 };
@@ -749,140 +752,72 @@ operator<=(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)

 // tuple_cat

-template <class _Tp, class _Up> struct __tuple_cat_type;
-
-template <class ..._Ttypes, class ..._Utypes>
-struct __tuple_cat_type<tuple<_Ttypes...>, __tuple_types<_Utypes...> >
-{
-    typedef tuple<_Ttypes..., _Utypes...> type;
-};
-
-template <class _ResultTuple, bool _Is_Tuple0TupleLike, class ..._Tuples>
-struct __tuple_cat_return_1
-{
-};
-
-template <class ..._Types, class _Tuple0>
-struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0>
-{
-    typedef typename __tuple_cat_type<tuple<_Types...>,
-            typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type>::type
-                                                                           type;
-};
-
-template <class ..._Types, class _Tuple0, class _Tuple1, class ..._Tuples>
-struct __tuple_cat_return_1<tuple<_Types...>, true, _Tuple0, _Tuple1, _Tuples...>
-    : public __tuple_cat_return_1<
-                 typename __tuple_cat_type<
-                     tuple<_Types...>,
-                     typename __make_tuple_types<typename remove_reference<_Tuple0>::type>::type
-                 >::type,
-                 __tuple_like<typename remove_reference<_Tuple1>::type>::value,
-                 _Tuple1, _Tuples...>
-{
-};
-
-template <class ..._Tuples> struct __tuple_cat_return;
-
-template <class _Tuple0, class ..._Tuples>
-struct __tuple_cat_return<_Tuple0, _Tuples...>
-    : public __tuple_cat_return_1<tuple<>,
-         __tuple_like<typename remove_reference<_Tuple0>::type>::value, _Tuple0,
-                                                                     _Tuples...>
-{
-};
-
-template <>
-struct __tuple_cat_return<>
-{
-    typedef tuple<> type;
-};
-
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
 inline _LIBCPP_INLINE_VISIBILITY
-tuple<>
-tuple_cat()
+tuple<_Tp..., _Up...>
+__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
 {
-    return tuple<>();
+    return tuple<_Tp..., _Up...>(get<_I1>(__x)..., get<_I2>(__y)...);
 }

-template <class _R, class _Indices, class _Tuple0, class ..._Tuples>
-struct __tuple_cat_return_ref_imp;
-
-template <class ..._Types, size_t ..._I0, class _Tuple0>
-struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>, _Tuple0>
-{
-    typedef typename remove_reference<_Tuple0>::type _T0;
-    typedef tuple<_Types..., typename __apply_cv<_Tuple0,
-                          typename tuple_element<_I0, _T0>::type>::type&&...> type;
-};
-
-template <class ..._Types, size_t ..._I0, class _Tuple0, class _Tuple1, class ..._Tuples>
-struct __tuple_cat_return_ref_imp<tuple<_Types...>, __tuple_indices<_I0...>,
-                                  _Tuple0, _Tuple1, _Tuples...>
-    : public __tuple_cat_return_ref_imp<
-         tuple<_Types..., typename __apply_cv<_Tuple0,
-               typename tuple_element<_I0,
-                  typename remove_reference<_Tuple0>::type>::type>::type&&...>,
-         typename __make_tuple_indices<tuple_size<typename
-                                 remove_reference<_Tuple1>::type>::value>::type,
-         _Tuple1, _Tuples...>
-{
-};
-
-template <class _Tuple0, class ..._Tuples>
-struct __tuple_cat_return_ref
-    : public __tuple_cat_return_ref_imp<tuple<>,
-               typename __make_tuple_indices<
-                        tuple_size<typename remove_reference<_Tuple0>::type>::value
-               >::type, _Tuple0, _Tuples...>
-{
-};
-
-template <class _Types, class _I0, class _J0>
-struct __tuple_cat;
-
-template <class ..._Types, size_t ..._I0, size_t ..._J0>
-struct __tuple_cat<tuple<_Types...>, __tuple_indices<_I0...>, __tuple_indices<_J0...> >
-{
-    template <class _Tuple0>
-    _LIBCPP_INLINE_VISIBILITY
-    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&>::type
-    operator()(tuple<_Types...> __t, _Tuple0&& __t0)
-    {
-        return _STD::forward_as_tuple(_STD::forward<_Types>(get<_I0>(__t))...,
-                                      get<_J0>(_STD::forward<_Tuple0>(__t0))...);
-    }
-
-    template <class _Tuple0, class _Tuple1, class ..._Tuples>
-    _LIBCPP_INLINE_VISIBILITY
-    typename __tuple_cat_return_ref<tuple<_Types...>&&, _Tuple0&&, _Tuple1&&, _Tuples&&...>::type
-    operator()(tuple<_Types...> __t, _Tuple0&& __t0, _Tuple1&& __t1, _Tuples&& ...__tpls)
-    {
-        typedef typename remove_reference<_Tuple0>::type _T0;
-        typedef typename remove_reference<_Tuple1>::type _T1;
-        return __tuple_cat<
-           tuple<_Types..., typename __apply_cv<_Tuple0, typename tuple_element<_J0, _T0>::type>::type&&...>,
-           typename __make_tuple_indices<sizeof ...(_Types) + tuple_size<_T0>::value>::type,
-           typename __make_tuple_indices<tuple_size<_T1>::value>::type>()
-                           (_STD::forward_as_tuple(
-                              _STD::forward<_Types>(get<_I0>(__t))...,
-                              get<_J0>(_STD::forward<_Tuple0>(__t0))...
-                            ),
-                            _STD::forward<_Tuple1>(__t1),
-                            _STD::forward<_Tuples>(__tpls)...);
-    }
-};
-
-template <class _Tuple0, class... _Tuples>
+template <class... _Tp, class... _Up>
 inline _LIBCPP_INLINE_VISIBILITY
-typename __tuple_cat_return<_Tuple0, _Tuples...>::type
-tuple_cat(_Tuple0&& __t0, _Tuples&&... __tpls)
+tuple<_Tp..., _Up...>
+tuple_cat(const tuple<_Tp...>& __x, const tuple<_Up...>& __y)
 {
-    typedef typename remove_reference<_Tuple0>::type _T0;
-    return __tuple_cat<tuple<>, __tuple_indices<>,
-                  typename __make_tuple_indices<tuple_size<_T0>::value>::type>()
-                  (tuple<>(), _STD::forward<_Tuple0>(__t0),
-                                            _STD::forward<_Tuples>(__tpls)...);
+    return __tuple_cat(__x, typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       __y, typename __make_tuple_indices<sizeof...(_Up)>::type());
+}
+
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline _LIBCPP_INLINE_VISIBILITY
+tuple<_Tp..., _Up...>
+__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, const tuple<_Up...>& __y, __tuple_indices<_I2...>)
+{
+    return tuple<_Tp..., _Up...>(_STD::forward<_Tp>(get<_I1>(__x))..., get<_I2>(__y)...);
+}
+
+template <class... _Tp, class... _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+tuple<_Tp..., _Up...>
+tuple_cat(tuple<_Tp...>&& __x, const tuple<_Up...>& __y)
+{
+    return __tuple_cat(_STD::move(__x), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       __y, typename __make_tuple_indices<sizeof...(_Up)>::type());
+}
+
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline _LIBCPP_INLINE_VISIBILITY
+tuple<_Tp..., _Up...>
+__tuple_cat(const tuple<_Tp...>& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
+{
+    return tuple<_Tp..., _Up...>(get<_I1>(__x)..., _STD::forward<_Up>(get<_I2>(__y))...);
+}
+
+template <class... _Tp, class... _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+tuple<_Tp..., _Up...>
+tuple_cat(const tuple<_Tp...>& __x, tuple<_Up...>&& __y)
+{
+    return __tuple_cat(__x, typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       _STD::move(__y), typename __make_tuple_indices<sizeof...(_Up)>::type());
+}
+
+template <class... _Tp, size_t ..._I1, class... _Up, size_t ..._I2>
+inline _LIBCPP_INLINE_VISIBILITY
+tuple<_Tp..., _Up...>
+__tuple_cat(tuple<_Tp...>&& __x, __tuple_indices<_I1...>, tuple<_Up...>&& __y, __tuple_indices<_I2...>)
+{
+    return tuple<_Tp..., _Up...>(_STD::forward<_Tp>(get<_I1>(__x))..., _STD::forward<_Up>(get<_I2>(__y))...);
+}
+
+template <class... _Tp, class... _Up>
+inline _LIBCPP_INLINE_VISIBILITY
+tuple<_Tp..., _Up...>
+tuple_cat(tuple<_Tp...>&& __x, tuple<_Up...>&& __y)
+{
+    return __tuple_cat(_STD::move(__x), typename __make_tuple_indices<sizeof...(_Tp)>::type(),
+                       _STD::move(__y), typename __make_tuple_indices<sizeof...(_Up)>::type());
 }

 template <class ..._Tp, class _Alloc>
--- a/include/type_traits
+++ b/include/type_traits
--- a/include/typeindex
+++ b/include/typeindex
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/typeinfo
+++ b/include/typeinfo
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/unordered_map
+++ b/include/unordered_map
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -424,9 +424,9 @@ public:
    void operator()(pointer __p)
    {
        if (__second_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.second));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.second));
        if (__first_constructed)
-            __alloc_traits::destroy(__na_, _STD::addressof(__p->__value_.first));
+            __alloc_traits::destroy(__na_, addressof(__p->__value_.first));
        if (__p)
            __alloc_traits::deallocate(__na_, __p, 1);
    }
@@ -979,10 +979,10 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0,
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first),
+    __node_traits::construct(__na, addressof(__h->__value_.first),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second),
+    __node_traits::construct(__na, addressof(__h->__value_.second),
                             _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -999,7 +999,7 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0)
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_),
+    __node_traits::construct(__na, addressof(__h->__value_),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
@@ -1032,9 +1032,9 @@ unordered_map<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(const key_type&
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first), __k);
+    __node_traits::construct(__na, addressof(__h->__value_.first), __k);
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second));
+    __node_traits::construct(__na, addressof(__h->__value_.second));
    __h.get_deleter().__second_constructed = true;
    return _STD::move(__h);
 }
@@ -1560,10 +1560,10 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.first),
+    __node_traits::construct(__na, addressof(__h->__value_.first),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
-    __node_traits::construct(__na, _STD::addressof(__h->__value_.second),
+    __node_traits::construct(__na, addressof(__h->__value_.second),
                             _STD::forward<_Args>(__args)...);
    __h.get_deleter().__second_constructed = true;
    return __h;
@@ -1580,7 +1580,7 @@ unordered_multimap<_Key, _Tp, _Hash, _Pred, _Alloc>::__construct_node(_A0&& __a0
 {
    __node_allocator& __na = __table_.__node_alloc();
    __node_holder __h(__node_traits::allocate(__na, 1), _D(__na));
-    __node_traits::construct(__na, _STD::addressof(__h->__value_),
+    __node_traits::construct(__na, addressof(__h->__value_),
                             _STD::forward<_A0>(__a0));
    __h.get_deleter().__first_constructed = true;
    __h.get_deleter().__second_constructed = true;
--- a/include/unordered_set
+++ b/include/unordered_set
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/utility
+++ b/include/utility
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -38,7 +38,7 @@ template <class T> typename remove_reference<T>::type&& move(T&&);
 template <class T>
    typename conditional
    <
-        !is_nothrow_move_constructible<T>::value && is_copy_constructible<T>::value,
+        !has_nothrow_move_constructor<T>::value && has_copy_constructor<T>::value,
        const T&,
        T&&
    >::type
@@ -100,10 +100,6 @@ 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>&);

-template<size_t I, class T1, class T2>
-    typename tuple_element<I, std::pair<T1, T2> >::type&&
-    get(std::pair<T1, T2>&&);
-
 }  // std

 */
@@ -178,7 +174,7 @@ inline _LIBCPP_INLINE_VISIBILITY
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
 typename conditional
 <
-    !is_nothrow_move_constructible<_Tp>::value && is_copy_constructible<_Tp>::value,
+    !has_nothrow_move_constructor<_Tp>::value && has_copy_constructor<_Tp>::value,
    const _Tp&,
    _Tp&&
 >::type
@@ -234,8 +230,6 @@ struct _LIBCPP_VISIBLE pair
                                   typename __make_tuple_types<_Tuple>::type>::type>(get<1>(__p)))
            {}

-
-
    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
        _LIBCPP_INLINE_VISIBILITY
        pair(piecewise_construct_t __pc, tuple<_Args1...> __first_args,
@@ -271,7 +265,6 @@ private:

 #ifndef _LIBCPP_HAS_NO_VARIADICS
    template <class... _Args1, class... _Args2, size_t... _I1, size_t... _I2>
-        _LIBCPP_INLINE_VISIBILITY
        pair(piecewise_construct_t,
             tuple<_Args1...>& __first_args, tuple<_Args2...>& __second_args,
             __tuple_indices<_I1...>, __tuple_indices<_I2...>);
@@ -432,16 +425,6 @@ struct __get_pair<0>
    _LIBCPP_INLINE_VISIBILITY
    const _T1&
    get(const pair<_T1, _T2>& __p) {return __p.first;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_INLINE_VISIBILITY
-    _T1&&
-    get(pair<_T1, _T2>&& __p) {return _STD::forward<_T1>(__p.first);}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };

 template <>
@@ -458,16 +441,6 @@ struct __get_pair<1>
    _LIBCPP_INLINE_VISIBILITY
    const _T2&
    get(const pair<_T1, _T2>& __p) {return __p.second;}
-
-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-    template <class _T1, class _T2>
-    static
-    _LIBCPP_INLINE_VISIBILITY
-    _T2&&
-    get(pair<_T1, _T2>&& __p) {return _STD::forward<_T2>(__p.second);}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
 };

 template <size_t _Ip, class _T1, class _T2>
@@ -486,18 +459,6 @@ get(const pair<_T1, _T2>& __p)
    return __get_pair<_Ip>::get(__p);
 }

-#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
-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)
-{
-    return __get_pair<_Ip>::get(_STD::move(__p));
-}
-
-#endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
-
 #endif  // _LIBCPP_HAS_NO_VARIADICS

 _LIBCPP_END_NAMESPACE_STD
--- a/include/valarray
+++ b/include/valarray
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

--- a/include/vector
+++ b/include/vector
@@ -3,8 +3,8 @@
 //
 //                     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.
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//

@@ -318,17 +318,17 @@ protected:
    _LIBCPP_INLINE_VISIBILITY pointer&              __end_cap()       {return __end_cap_.first();}
    _LIBCPP_INLINE_VISIBILITY const pointer&        __end_cap() const {return __end_cap_.first();}

-    _LIBCPP_INLINE_VISIBILITY __vector_base();
-    _LIBCPP_INLINE_VISIBILITY __vector_base(const allocator_type& __a);
+    __vector_base();
+    __vector_base(const allocator_type& __a);
    ~__vector_base();

    _LIBCPP_INLINE_VISIBILITY void clear() {__destruct_at_end(__begin_);}
    _LIBCPP_INLINE_VISIBILITY size_type capacity() const {return static_cast<size_type>(__end_cap() - __begin_);}

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

    _LIBCPP_INLINE_VISIBILITY
    void __copy_assign_alloc(const __vector_base& __c)
@@ -484,9 +484,7 @@ public:
    template <class _ForwardIterator>
        vector(_ForwardIterator __first, _ForwardIterator __last, const allocator_type& __a,
               typename enable_if<__is_forward_iterator<_ForwardIterator>::value>::type* = 0);
-    _LIBCPP_INLINE_VISIBILITY
    vector(initializer_list<value_type> __il);
-    _LIBCPP_INLINE_VISIBILITY
    vector(initializer_list<value_type> __il, const allocator_type& __a);
 #ifdef _LIBCPP_DEBUG
    _LIBCPP_INLINE_VISIBILITY
@@ -495,14 +493,10 @@ public:

    vector(const vector& __x);
    vector(const vector& __x, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
    vector& operator=(const vector& __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY
    vector(vector&& __x);
-    _LIBCPP_INLINE_VISIBILITY
    vector(vector&& __x, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY
    vector& operator=(vector&& __x);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
@@ -532,10 +526,10 @@ public:

    _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const {return this->__alloc();}

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

    _LIBCPP_INLINE_VISIBILITY reverse_iterator       rbegin()         {return       reverse_iterator(end());}
    _LIBCPP_INLINE_VISIBILITY const_reverse_iterator rbegin()  const  {return const_reverse_iterator(end());}
@@ -569,7 +563,7 @@ public:
    _LIBCPP_INLINE_VISIBILITY const value_type* data() const
        {return _STD::__to_raw_pointer(this->__begin_);}

-    _LIBCPP_INLINE_VISIBILITY void push_back(const_reference __x);
+    void push_back(const_reference __x);
 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
    void push_back(value_type&& __x);
 #ifndef _LIBCPP_HAS_NO_VARIADICS
@@ -607,7 +601,7 @@ public:
    iterator insert(const_iterator __position, initializer_list<value_type> __il)
        {return insert(__position, __il.begin(), __il.end());}

-    _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
+    iterator erase(const_iterator __position);
    iterator erase(const_iterator __first, const_iterator __last);

    _LIBCPP_INLINE_VISIBILITY void clear() {__base::clear();}
@@ -620,12 +614,16 @@ public:
    bool __invariants() const;

 private:
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
+    void __invalidate_all_iterators();
    void allocate(size_type __n);
    void deallocate();
-    _LIBCPP_INLINE_VISIBILITY size_type __recommend(size_type __new_size) const;
+    size_type __recommend(size_type __new_size) const;
    void __construct_at_end(size_type __n);
+        void __construct_at_end(size_type __n, false_type);
+        void __construct_at_end(size_type __n, true_type);
    void __construct_at_end(size_type __n, const_reference __x);
+        void __construct_at_end(size_type __n, const_reference __x, false_type);
+        void __construct_at_end(size_type __n, const_reference __x, true_type);
    template <class _ForwardIterator>
        typename enable_if
        <
@@ -636,9 +634,7 @@ private:
    void __move_construct_at_end(pointer __first, pointer __last);
    void __append(size_type __n);
    void __append(size_type __n, const_reference __x);
-    _LIBCPP_INLINE_VISIBILITY
    iterator       __make_iter(pointer __p);
-    _LIBCPP_INLINE_VISIBILITY
    const_iterator __make_iter(const_pointer __p) const;
    void __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v);
    pointer __swap_out_circular_buffer(__split_buffer<value_type, allocator_type&>& __v, pointer __p);
@@ -735,8 +731,16 @@ vector<_Tp, _Allocator>::__recommend(size_type __new_size) const
 //  Precondition:  size() + __n <= capacity()
 //  Postcondition:  size() == size() + __n
 template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
+{
+    __construct_at_end(__n, __is_zero_default_constructible<value_type>());
+}
+
+template <class _Tp, class _Allocator>
+void
+vector<_Tp, _Allocator>::__construct_at_end(size_type __n, false_type)
 {
    allocator_type& __a = this->__alloc();
    do
@@ -747,6 +751,15 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n)
    } while (__n > 0);
 }

+template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
+void
+vector<_Tp, _Allocator>::__construct_at_end(size_type __n, true_type)
+{
+    _STD::memset(this->__end_, 0, __n*sizeof(value_type));
+    this->__end_ += __n;
+}
+
 //  Copy constructs __n objects starting at __end_ from __x
 //  throws if construction throws
 //  Precondition:  __n > 0
@@ -757,6 +770,14 @@ template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 void
 vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
+{
+    __construct_at_end(__n, __x, integral_constant<bool, has_trivial_copy_constructor<value_type>::value &&
+                                                         has_trivial_copy_assign<value_type>::value>());
+}
+
+template <class _Tp, class _Allocator>
+void
+vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, false_type)
 {
    allocator_type& __a = this->__alloc();
    do
@@ -767,6 +788,15 @@ vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x)
    } while (__n > 0);
 }

+template <class _Tp, class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
+void
+vector<_Tp, _Allocator>::__construct_at_end(size_type __n, const_reference __x, true_type)
+{
+    _STD::fill_n(this->__end_, __n, __x);
+    this->__end_ += __n;
+}
+
 template <class _Tp, class _Allocator>
 template <class _ForwardIterator>
 typename enable_if
@@ -1101,7 +1131,7 @@ vector<_Tp, _Allocator>::assign(size_type __n, const_reference __u)
    if (__n <= capacity())
    {
        size_type __s = size();
-        _STD::fill_n(this->__begin_, _STD::min(__n, __s), __u);
+        _STD::fill_n(this->__begin_, min(__n, __s), __u);
        if (__n > __s)
            __construct_at_end(__n - __s, __u);
        else
@@ -1727,8 +1757,8 @@ private:
        {return (__n - 1) / __bits_per_word + 1;}

 public:
-    _LIBCPP_INLINE_VISIBILITY vector();
-    _LIBCPP_INLINE_VISIBILITY explicit vector(const allocator_type& __a);
+    vector();
+    explicit vector(const allocator_type& __a);
    ~vector();
    explicit vector(size_type __n);
    vector(size_type __n, const value_type& __v);
@@ -1755,9 +1785,9 @@ public:
    vector(initializer_list<value_type> __il, const allocator_type& __a);

 #ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES
-    _LIBCPP_INLINE_VISIBILITY vector(vector&& __v);
+    vector(vector&& __v);
    vector(vector&& __v, const allocator_type& __a);
-    _LIBCPP_INLINE_VISIBILITY vector& operator=(vector&& __v);
+    vector& operator=(vector&& __v);
 #endif  // _LIBCPP_HAS_NO_RVALUE_REFERENCES
    _LIBCPP_INLINE_VISIBILITY
    vector& operator=(initializer_list<value_type> __il)
@@ -1844,7 +1874,7 @@ public:
    iterator insert(const_iterator __position, initializer_list<value_type> __il)
        {return insert(__position, __il.begin(), __il.end());}

-    _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __position);
+    iterator erase(const_iterator __position);
    iterator erase(const_iterator __first, const_iterator __last);

    _LIBCPP_INLINE_VISIBILITY void clear() {__size_ = 0;}
@@ -1857,13 +1887,13 @@ public:
    bool __invariants() const;

 private:
-    _LIBCPP_INLINE_VISIBILITY void __invalidate_all_iterators();
+    void __invalidate_all_iterators();
    void allocate(size_type __n);
    void deallocate();
    _LIBCPP_INLINE_VISIBILITY static size_type __align(size_type __new_size)
        {return __new_size + (__bits_per_word-1) & ~(__bits_per_word-1);};
-    _LIBCPP_INLINE_VISIBILITY  size_type __recommend(size_type __new_size) const;
-    _LIBCPP_INLINE_VISIBILITY void __construct_at_end(size_type __n, bool __x);
+    size_type __recommend(size_type __new_size) const;
+    void __construct_at_end(size_type __n, bool __x);
    template <class _ForwardIterator>
        typename enable_if
        <
@@ -2220,6 +2250,7 @@ vector<bool, _Allocator>::vector(initializer_list<value_type> __il, const alloca
 }

 template <class _Allocator>
+_LIBCPP_INLINE_VISIBILITY inline
 vector<bool, _Allocator>::~vector()
 {
    if (__begin_ != 0)
@@ -2724,6 +2755,10 @@ struct _LIBCPP_VISIBLE hash<vector<bool, _Allocator> >
        {return __vec.__hash_code();}
 };

+template <class _Tp, class _Allocator>
+struct __is_zero_default_constructible<vector<_Tp, _Allocator> >
+    : public integral_constant<bool, __is_zero_default_constructible<_Allocator>::value> {};
+
 template <class _Tp, class _Allocator>
 _LIBCPP_INLINE_VISIBILITY inline
 bool
--- a/lib/CMakeLists.txt
+++ b/lib/CMakeLists.txt
@@ -1,57 +0,0 @@
-# Get sources
-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/*)
-  # 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)
-    source_group("Header Files" FILES ${headers})
-  endif()
-endif()
-
-if (LIBCXX_ENABLE_SHARED)
-  add_library(cxx SHARED
-    ${sources}
-    )
-else()
-  add_library(cxx STATIC
-    ${sources}
-    )
-endif()
-
-# Generate library list.
-append_if(libraries LIBCXX_HAS_PTHREAD_LIB pthread)
-append_if(libraries LIBCXX_HAS_C_LIB c)
-append_if(libraries LIBCXX_HAS_M_LIB m)
-append_if(libraries LIBCXX_HAS_GCC_S_LIB gcc_s)
-
-target_link_libraries(cxx ${libraries})
-
-# Setup flags.
-append_if(compile_flags LIBCXX_HAS_FPIC_FLAG -fPIC)
-append_if(link_flags LIBCXX_HAS_NODEFAULTLIBS_FLAG -nodefaultlibs)
-
-set_target_properties(cxx
-  PROPERTIES
-    COMPILE_FLAGS "${compile_flags}"
-    LINK_FLAGS    "${link_flags}"
-    OUTPUT_NAME   "c++"
-    VERSION       "1.0"
-    SOVERSION     "1"
-  )
-
-install(TARGETS cxx
-  LIBRARY DESTINATION lib
-  ARCHIVE DESTINATION lib
-  )
-
-install(DIRECTORY ../include/
-  DESTINATION include/libcxx/v1
-  FILES_MATCHING
-  PATTERN "*"
-  PATTERN ".svn" EXCLUDE
-  PATTERN ".git" EXCLUDE
-  )
-
--- a/Show More
+++ b/Show More